def _run_importer(self):
"""
Create an instance of the plugin, run the importer, and
remove/unregister the plugin instance so a new instance can
be created when this method is run again.
This is a convenience method that can be called to setup, exercise
and teardown the system under test after setting any config options
and before assertions are made regarding changes to the filesystem.
"""
# Setup
# Create an instance of the plugin
plugins.find_plugins()
# Exercise
# Run the importer
self.importer.run()
# Teardown
if plugins._instances:
classes = list(plugins._classes)
# Unregister listners
del classes[0].listeners['import_task_files'][0]
# Delete the plugin instance so a new one gets created for each test
del plugins._instances[classes[0]]
def _run_importer(self):
"""
Create an instance of the plugin, run the importer, and
remove/unregister the plugin instance so a new instance can
be created when this method is run again.
This is a convenience method that can be called to setup, exercise
and teardown the system under test after setting any config options
and before assertions are made regarding changes to the filesystem.
"""
# Setup
# Create an instance of the plugin
plugins.find_plugins()
# Exercise
# Run the importer
self.importer.run()
# Teardown
if plugins._instances:
classes = list(plugins._classes)
# Unregister listners
del classes[0].listeners['import_task_files'][0]
# Delete the plugin instance so a new one gets created for each test
del plugins._instances[classes[0]]
def setup_beets(self, cfg=None):
if cfg is not None and type(cfg) is dict:
self._CFG.update(cfg)
plugins._classes = {self._CFG["plugin"]}
if self._CFG["extra_plugins"]:
plugins.load_plugins(self._CFG["extra_plugins"])
# copy configuration file to beets dir
config_file = os.path.join(self._test_config_dir_,
self._CFG["config_file"]).decode()
file_list = [{'file_name': 'config.yaml', 'file_path': config_file}]
self._copy_files_to_beetsdir(file_list)
self.config = beets.config
self.config.clear()
self.config.read()
self.config['plugins'] = []
self.config['verbose'] = True
self.config['ui']['color'] = False
self.config['threaded'] = False
self.config['import']['copy'] = False
self.config['directory'] = self.beetsdir.decode()
self.lib = beets.library.Library(':memory:', self.beetsdir.decode())
# This will initialize the plugins
plugins.find_plugins()
def _setup_beets(self, config_file: bytes):
self.addCleanup(self.teardown_beets)
os.environ['BEETSDIR'] = self.mkdtemp()
self.config = beets.config
self.config.clear()
# add user configuration
config_file = format(
os.path.join(self._test_config_dir_, config_file).decode())
shutil.copyfile(config_file, self.config.user_config_path())
self.config.read()
self.config['plugins'] = []
self.config['verbose'] = True
self.config['ui']['color'] = False
self.config['threaded'] = False
self.config['import']['copy'] = False
os.makedirs(self._test_target_dir, exist_ok=True)
libdir = self.mkdtemp()
self.config['directory'] = libdir
self.libdir = bytestring_path(libdir)
self.lib = beets.library.Library(':memory:', self.libdir)
# This will initialize (create instance) of the plugins
plugins.find_plugins()
def _run_importer(self):
"""
Create an instance of the plugin, run the importer, and
remove/unregister the plugin instance so a new instance can
be created when this method is run again.
This is a convenience method that can be called to setup, exercise
and teardown the system under test after setting any config options
and before assertions are made regarding changes to the filesystem.
"""
# Setup
# Create an instance of the plugin
plugins.find_plugins()
# Exercise
# Run the importer
self.importer.run()
# Fake the occurence of the cli_exit event
plugins.send('cli_exit', lib=self.lib)
# Teardown
if plugins._instances:
classes = list(plugins._classes)
# Unregister listners
for event in classes[0].listeners:
del classes[0].listeners[event][0]
# Delete the plugin instance so a new one gets created for each test
del plugins._instances[classes[0]]
log.debug("--- library structure")
self._list_files(self.lib_dir)
def _run_importer(self):
"""
Create an instance of the plugin, run the importer, and
remove/unregister the plugin instance so a new instance can
be created when this method is run again.
This is a convenience method that can be called to setup, exercise
and teardown the system under test after setting any config options
and before assertions are made regarding changes to the filesystem.
"""
# Setup
# Create an instance of the plugin
plugins.find_plugins()
# Exercise
# Run the importer
self.importer.run()
# Fake the occurence of the cli_exit event
plugins.send('cli_exit', lib=self.lib)
# Teardown
if plugins._instances:
classes = list(plugins._classes)
# Unregister listners
for event in classes[0].listeners:
del classes[0].listeners[event][0]
# Delete the plugin instance so a new one gets created for each test
del plugins._instances[classes[0]]
log.debug("--- library structure")
self._list_files(self.lib_dir)
def get_fields(cls):
"""Returns Album fields available for queries and format strings."""
plugin_fields = []
for plugin in plugins.find_plugins():
plugin_fields += plugin.album_template_fields.keys()
return (cls._fields.keys() + cls._getters().keys() +
cls._types.keys()), plugin_fields
def pluginload(self):
self.zero_plugin = None
if self.config['auto'] and self.config['update_database']:
for plugin in find_plugins():
if plugin.name == 'zero':
self.zero_plugin = plugin
break
def commands(self):
for plugin in plugins.find_plugins():
if plugin.name == 'spotify':
self.spotify = plugin
break
else:
raise ui.UserError('spotify plugin is required')
def explicits(lib, opts, args):
args = ui.decargs(args)
items = lib.items(args)
results = self.spotify._match_library_tracks(lib, args)
if results:
for item, track in zip(items, results):
if track['explicit']:
title = track['name']
album = track['album']['name']
artist = track['artists'][0]['name']
tracknum = track['track_number']
url = track['external_urls']['spotify']
plugins.send("spotify_explicit_track",
lib=lib,
track=track,
item=item)
print('{} - {} - {} - {} - {}'.format(
album, tracknum, artist, title, url))
explicit_cmd = ui.Subcommand('spotify-explicit', help=u'')
explicit_cmd.parser.add_all_common_options()
explicit_cmd.func = explicits
return [explicit_cmd]
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 get_fields(cls):
"""Returns Album fields available for queries and format strings."""
plugin_fields = []
for plugin in plugins.find_plugins():
plugin_fields += plugin.album_template_fields.keys()
return (cls._fields.keys() + cls._getters().keys() +
cls._types.keys()), plugin_fields
def show_version(lib, opts, args):
print_("beets version %s" % beets.__version__)
# Show plugins.
names = [p.name for p in plugins.find_plugins()]
if names:
print_("plugins:", ", ".join(names))
else:
print_("no plugins loaded")
def test_cli_config_file_loads_plugin_commands(self):
cli_config_path = os.path.join(self.temp_dir, b'config.yaml')
with open(cli_config_path, 'w') as file:
file.write('pluginpath: %s\n' % _common.PLUGINPATH)
file.write('plugins: test')
self.run_command('--config', cli_config_path, 'plugin', lib=None)
self.assertTrue(plugins.find_plugins()[0].is_test_plugin)
def show_version(lib, opts, args):
print_('beets version %s' % beets.__version__)
# Show plugins.
names = [p.name for p in plugins.find_plugins()]
if names:
print_('plugins:', ', '.join(names))
else:
print_('no plugins loaded')
def show_version(lib, opts, args):
print_('beets version %s' % beets.__version__)
# Show plugins.
names = [p.name for p in plugins.find_plugins()]
if names:
print_('plugins:', ', '.join(names))
else:
print_('no plugins loaded')
def test_cli_config_file_loads_plugin_commands(self):
cli_config_path = os.path.join(self.temp_dir, b'config.yaml')
with open(cli_config_path, 'w') as file:
file.write('pluginpath: %s\n' % _common.PLUGINPATH)
file.write('plugins: test')
self.run_command('--config', cli_config_path, 'plugin', lib=None)
self.assertTrue(plugins.find_plugins()[0].is_test_plugin)
def test_cli_config_file_loads_plugin_commands(self):
plugin_path = os.path.join(_common.RSRC, "beetsplug")
cli_config_path = os.path.join(self.temp_dir, "config.yaml")
with open(cli_config_path, "w") as file:
file.write("pluginpath: %s\n" % plugin_path)
file.write("plugins: test")
ui._raw_main(["--config", cli_config_path, "plugin"])
self.assertTrue(plugins.find_plugins()[0].is_test_plugin)
def test_cli_config_file_loads_plugin_commands(self):
plugin_path = os.path.join(_common.RSRC, 'beetsplug')
cli_config_path = os.path.join(self.temp_dir, 'config.yaml')
with open(cli_config_path, 'w') as file:
file.write('pluginpath: %s\n' % plugin_path)
file.write('plugins: test')
ui._raw_main(['--config', cli_config_path, 'plugin'])
self.assertTrue(plugins.find_plugins()[0].is_test_plugin)
def loaded(self):
for plugin in plugins.find_plugins():
if plugin.name == "the":
plugin.template_funcs['the'] = lambda text: the_template_func(
plugin, text)
break
elif plugin.name == "kergoth":
plugin.the = lambda text: the_template_func(plugin, text)
else:
raise ui.UserError(f"'the' plugin is required for {self.name}")
def test_cli_config_file_loads_plugin_commands(self):
plugin_path = os.path.join(_common.RSRC, 'beetsplug')
cli_config_path = os.path.join(self.temp_dir, 'config.yaml')
with open(cli_config_path, 'w') as file:
file.write('pluginpath: %s\n' % plugin_path)
file.write('plugins: test')
ui._raw_main(['--config', cli_config_path, 'plugin'])
self.assertTrue(plugins.find_plugins()[0].is_test_plugin)
def loaded(self):
# Add our own artsource to the fetchart plugin.
# FIXME: This is ugly, but i didn't find another way to extend fetchart
# without declaring a new plugin.
if self.config['art']:
for plugin in plugins.find_plugins():
if isinstance(plugin, fetchart.FetchArtPlugin):
plugin.sources = [BandcampAlbumArt(plugin._log, self.config)] + plugin.sources
fetchart.ART_SOURCES[u'bandcamp'] = BandcampAlbumArt
break
def _show_plugin_fields(album):
plugin_fields = []
for plugin in plugins.find_plugins():
if album:
fdict = plugin.album_template_fields
else:
fdict = plugin.template_fields
plugin_fields += fdict.keys()
if plugin_fields:
print("Template fields from plugins:")
_print_rows(plugin_fields)
def _show_plugin_fields(album):
plugin_fields = []
for plugin in plugins.find_plugins():
if album:
fdict = plugin.album_template_fields
else:
fdict = plugin.template_fields
plugin_fields += fdict.keys()
if plugin_fields:
print("Template fields from plugins:")
_print_rows(plugin_fields)
def show_version(lib, config, opts, args):
print_("beets version %s" % beets.__version__)
# Show plugins.
names = []
for plugin in plugins.find_plugins():
modname = plugin.__module__
names.append(modname.split(".")[-1])
if names:
print_("plugins:", ", ".join(names))
else:
print_("no plugins loaded")
def show_version(lib, config, opts, args):
print_('beets version %s' % beets.__version__)
# Show plugins.
names = []
for plugin in plugins.find_plugins():
modname = plugin.__module__
names.append(modname.split('.')[-1])
if names:
print_('plugins:', ', '.join(names))
else:
print_('no plugins loaded')
def show_version(lib, config, opts, args):
print 'beets version %s' % beets.__version__
# Show plugins.
names = []
for plugin in plugins.find_plugins():
modname = plugin.__module__
names.append(modname.split('.')[-1])
if names:
print 'plugins:', ', '.join(names)
else:
print 'no plugins loaded'
def fields_func(lib, opts, args):
print("Item fields:")
print(" " + "\n ".join([key for key in library.ITEM_KEYS]))
print("\nAlbum fields:")
print(" " + "\n ".join([key for key in library.ALBUM_KEYS]))
plugin_fields = []
for plugin in plugins.find_plugins():
plugin_fields += plugin.template_fields.keys()
if plugin_fields:
print("\nTemplate fields from plugins:")
print(" " + "\n ".join(plugin_fields))
def loaded(self) -> None:
"""Add our own artsource to the fetchart plugin."""
# TODO: This is ugly, but i didn't find another way to extend fetchart
# without declaring a new plugin.
if self.config["art"]:
for plugin in plugins.find_plugins():
if isinstance(plugin, fetchart.FetchArtPlugin):
plugin.sources = [
BandcampAlbumArt(plugin._log, self.config)
] + plugin.sources
fetchart.ART_SOURCES[DATA_SOURCE] = BandcampAlbumArt
fetchart.SOURCE_NAMES[BandcampAlbumArt] = DATA_SOURCE
break
def loaded(self):
# Add our own artsource to the fetchart plugin.
# FIXME: This is ugly, but i didn't find another way to extend fetchart
# without declaring a new plugin.
if self.config['art']:
for plugin in plugins.find_plugins():
if isinstance(plugin, fetchart.FetchArtPlugin):
plugin.sources = [
DiscogsAlbumArt(plugin._log, self.discogs_client)
] + plugin.sources
fetchart.ART_SOURCES['discogs'] = DiscogsAlbumArt
fetchart.SOURCE_NAMES[DiscogsAlbumArt] = 'discogs'
break
def _get_info(self, items, write, force):
self.absubmit, self.acousticbrainz = None, None
for plugin in find_plugins():
if plugin.name == 'absubmit':
self.absubmit = plugin
elif plugin.name == 'acousticbrainz':
self.acousticbrainz = plugin
if not self.absubmit or not self.acousticbrainz:
raise ui.UserError(
'absubmit and acousticbrainz are required for this plugin')
def func(item):
return self.analyze(item, write, force)
util.par_map(func, self.included_items(items, force))
