def commands(self): """Add the last-import command.""" last_import = Subcommand( 'last-import', help=u'print the most recently imported items.') last_import.parser.add_all_common_options() last_import.func = self.last_import return [last_import]
def commands(self): def print_unimported(lib, opts, args): ignore_exts = [ ('.' + x).encode() for x in self.config["ignore_extensions"].as_str_seq() ] ignore_dirs = [ os.path.join(lib.directory, x.encode()) for x in self.config["ignore_subdirectories"].as_str_seq() ] in_folder = { os.path.join(r, file) for r, d, f in os.walk(lib.directory) for file in f if not any([file.endswith(ext) for ext in ignore_exts] + [r in ignore_dirs]) } in_library = {x.path for x in lib.items()} art_files = {x.artpath for x in lib.albums()} for f in in_folder - in_library - art_files: print_(util.displayable_path(f)) unimported = Subcommand( 'unimported', help='list all files in the library folder which are not listed' ' in the beets library database') unimported.func = print_unimported return [unimported]
def commands(self): """Add subcommand used to run the AURA server.""" def run_aura(lib, opts, args): """Run the application using Flask's built in-server. Args: lib: A beets Library object (not used). opts: Command line options. An optparse.Values object. args: The list of arguments to process (not used). """ app = create_app() # Start the built-in server (not intended for production) app.run( host=self.config["host"].get(str), port=self.config["port"].get(int), debug=opts.debug, threaded=True, ) run_aura_cmd = Subcommand("aura", help="run an AURA server") run_aura_cmd.parser.add_option( "-d", "--debug", action="store_true", default=False, help="use Flask debug mode", ) run_aura_cmd.func = run_aura return [run_aura_cmd]
def commands(self): lyrics_cmd = Subcommand('lyrics', help='fetch lyrics') lyrics_cmd.func = self.lyrics_func lyrics_cmd.parser.add_option('-f', '--force', action='store_true', default=None, help='overwrite tag updates') lyrics_cmd.parser.add_option('-p', '--processes', dest='processes', help='number of concurrent threads to run') return [lyrics_cmd]
def commands(self): normalize = Subcommand( 'normalize', help='normalizes the tag containers to ID3v2.4 and ID3v1.0') normalize.parser.add_all_common_options() normalize.func = self.do_normalize return [normalize]
def commands(self): play_command = Subcommand("play", help="send music to a player as a playlist") play_command.parser.add_option( "-a", "--album", action="store_true", default=False, help="query and load albums rather than tracks" ) play_command.func = play_music return [play_command]
def commands(self): play_command = Subcommand( 'play', help='send music to a player as a playlist' ) play_command.parser.add_album_option() play_command.func = self.play_music return [play_command]
def commands(self): play_command = Subcommand('play', help='send query results to music player as playlist.') play_command.parser.add_option('-a', '--album', action='store_true', default=False, help='query and load albums(folders) rather then tracks.') play_command.func = play_music return [play_command]
def commands(self): bad_command = Subcommand('bad', help='check for corrupt or missing files') bad_command.parser.add_option( '-v', '--verbose', action='store_true', default=False, dest='verbose', help='view results for both the bad and uncorrupted files' ) bad_command.func = self.command return [bad_command]
def commands(self): mbupdate = Subcommand('mbupdate', help=u'Update MusicBrainz collection') mbupdate.parser.add_option('-r', '--remove', action='store_true', default=None, dest='remove', help='Remove albums not in beets library') mbupdate.func = self.update_collection return [mbupdate]
def commands(self): bad_command = Subcommand('bad', help=u'check for corrupt or missing files') bad_command.parser.add_option( u'-v', u'--verbose', action='store_true', default=False, dest='verbose', help=u'view results for both the bad and uncorrupted files' ) bad_command.func = self.command return [bad_command]
def commands(self): mbupdate = Subcommand('mbupdate', help='Update MusicBrainz collection') mbupdate.parser.add_option('-r', '--remove', action='store_true', default=None, dest='remove', help='Remove albums not in beets library') mbupdate.func = self.update_collection return [mbupdate]
def commands(self): play_command = Subcommand('play', help='send music to a player as a playlist') play_command.parser.add_option( '-a', '--album', action='store_true', default=False, help='query and load albums rather than tracks') play_command.func = play_music return [play_command]
def commands(self): play_command = Subcommand('play', help='send music to a player as a playlist') play_command.parser.add_album_option() play_command.parser.add_option( '-A', '--args', action='store', help='add additional arguments to the command', ) play_command.func = self.play_music return [play_command]
def commands(self): play_command = Subcommand( 'play', help='send music to a player as a playlist' ) play_command.parser.add_option( '-a', '--album', action='store_true', default=False, help='query and load albums rather than tracks' ) play_command.func = play_music return [play_command]
def commands(self): zero_command = Subcommand('zero', help='set fields to null') def zero_fields(lib, opts, args): if not decargs(args) and not input_yn( u"Remove fields for all items? (Y/n)", True): return for item in lib.items(decargs(args)): self.process_item(item) zero_command.func = zero_fields return [zero_command]
def commands(self): thumbnails_command = Subcommand("thumbnails", help="Create album thumbnails") thumbnails_command.parser.add_option( '-f', '--force', dest='force', action='store_true', default=False, help='force regeneration of thumbnails deemed fine (existing & ' 'recent enough)') thumbnails_command.parser.add_option( '--dolphin', dest='dolphin', action='store_true', default=False, help="create Dolphin-compatible thumbnail information (for KDE)") thumbnails_command.func = self.process_query return [thumbnails_command]
def commands(self): cmds = Subcommand('wlg', help='get genres with whatlastgenre') cmds.parser.add_option( '-v', '--verbose', dest='verbose', action='count', default=0, help='verbose output (-vv for debug)') cmds.parser.add_option( '-f', '--force', dest='force', action='store_true', default=False, help='force overwrite existing genres') cmds.parser.add_option( '-u', '--update-cache', dest='cache', action='store_true', default=False, help='force update cache') cmds.func = self.commanded return [cmds]
def commands(self): play_command = Subcommand( 'play', help=u'send music to a player as a playlist' ) play_command.parser.add_album_option() play_command.parser.add_option( u'-A', u'--args', action='store', help=u'add additional arguments to the command', ) play_command.func = self.play_music return [play_command]
def commands(self): thumbnails_command = Subcommand("thumbnails", help=u"Create album thumbnails") thumbnails_command.parser.add_option( u'-f', u'--force', dest='force', action='store_true', default=False, help=u'force regeneration of thumbnails deemed fine (existing & ' u'recent enough)') thumbnails_command.parser.add_option( u'--dolphin', dest='dolphin', action='store_true', default=False, help=u"create Dolphin-compatible thumbnail information (for KDE)") thumbnails_command.func = self.process_query return [thumbnails_command]
def commands(self): airsonicsync = Subcommand('airsonicsync', help='sync new imports to the airsonic monthly playlist') airsonicsync.func = self.sync airsonictest = Subcommand('airsonictest', help='ping the airsonic server defined in the config') airsonictest.func = self.test airsonicscan = Subcommand('airsonicscan', help='run a scan on the airsonic server') airsonicscan.func = self.scan return [airsonicsync, airsonictest, airsonicscan]
def __init__(self): super(MissingPlugin, self).__init__() self.config.add({ 'count': False, 'total': False, 'album': False, }) self.album_template_fields['missing'] = _missing_count self._command = Subcommand('missing', help=__doc__, aliases=['miss']) self._command.parser.add_option(u'-c', u'--count', dest='count', action='store_true', help=u'count missing tracks per album') self._command.parser.add_option(u'-t', u'--total', dest='total', action='store_true', help=u'count total of missing tracks') self._command.parser.add_option( u'-a', u'--album', dest='album', action='store_true', help=u'show missing albums for artist instead of tracks') self._command.parser.add_format_option()
def __init__(self): super(MissingPlugin, self).__init__() self.config.add({ 'format': None, 'count': False, 'total': False, }) self.album_template_fields['missing'] = _missing_count self._command = Subcommand('missing', help=__doc__, aliases=['miss']) self._command.parser.add_option('-f', '--format', dest='format', action='store', type='string', help='print with custom FORMAT', metavar='FORMAT') self._command.parser.add_option('-c', '--count', dest='count', action='store_true', help='count missing tracks per album') self._command.parser.add_option('-t', '--total', dest='total', action='store_true', help='count total of missing tracks')
def __init__(self): super(DuplicatesPlugin, self).__init__() self.config.add({'format': ''}) self.config.add({'count': False}) self.config.add({'album': False}) self.config.add({'full': False}) self._command = Subcommand('duplicates', help=__doc__, aliases=['dup']) self._command.parser.add_option('-f', '--format', dest='format', action='store', type='string', help='print with custom FORMAT', metavar='FORMAT') self._command.parser.add_option('-c', '--count', dest='count', action='store_true', help='count duplicate tracks or\ albums') self._command.parser.add_option('-a', '--album', dest='album', action='store_true', help='show duplicate albums instead\ of tracks') self._command.parser.add_option('-F', '--full', dest='full', action='store_true', help='show all versions of duplicate\ tracks or albums')
def commands(self): tag_copy_command = Subcommand( 'tagcopy', help='copy the contents of one tag to another', aliases=['tc']) def copy_tags(lib, opts, args): items = list(lib.items(decargs(args))) for item in items: item = self.process_item(item) item.store() item.write() tag_copy_command.func = copy_tags return [tag_copy_command]
def commands(self): play_command = Subcommand( 'play', help=u'send music to a player as a playlist' ) play_command.parser.add_album_option() play_command.parser.add_option( u'-A', u'--args', action='store', help=u'add additional arguments to the command', ) play_command.parser.add_option( u'-y', u'--yes', action="store_true", help=u'skip the warning threshold', ) play_command.func = self._play_command return [play_command]
def __init__(self): super(DuplicatesPlugin, self).__init__() self.config.add({ 'format': '', 'count': False, 'album': False, 'full': False, 'path': False, 'keys': ['mb_trackid', 'mb_albumid'], 'checksum': None, 'copy': False, 'move': False, 'delete': False, 'tag': False, }) self._command = Subcommand('duplicates', help=__doc__, aliases=['dup']) self._command.parser.add_option('-c', '--count', dest='count', action='store_true', help='show duplicate counts') self._command.parser.add_option('-C', '--checksum', dest='checksum', action='store', metavar='PROG', help='report duplicates based on' ' arbitrary command') self._command.parser.add_option('-d', '--delete', dest='delete', action='store_true', help='delete items from library and ' 'disk') self._command.parser.add_option('-F', '--full', dest='full', action='store_true', help='show all versions of duplicate' ' tracks or albums') self._command.parser.add_option('-k', '--keys', dest='keys', action='callback', metavar='KEY1 KEY2', callback=vararg_callback, help='report duplicates based on keys') self._command.parser.add_option('-m', '--move', dest='move', action='store', metavar='DEST', help='move items to dest') self._command.parser.add_option('-o', '--copy', dest='copy', action='store', metavar='DEST', help='copy items to dest') self._command.parser.add_option('-t', '--tag', dest='tag', action='store', help='tag matched items with \'k=v\'' ' attribute') self._command.parser.add_all_common_options()
def commands(self): play_command = Subcommand('play', help=u'send music to a player as a playlist') play_command.parser.add_album_option() play_command.parser.add_option( u'-A', u'--args', action='store', help=u'add additional arguments to the command', ) play_command.parser.add_option( u'-y', u'--yes', action="store_true", help=u'skip the warning threshold', ) play_command.func = self._play_command return [play_command]
def commands(self): def build_playlist(lib, opts, args): self.config.set_args(opts) ids = self.config['playlist_ids'].as_str_seq() if self.config['playlist_names'].as_str_seq(): playlists = ElementTree.fromstring( self.send('getPlaylists').text)[0] if playlists.attrib.get('code', '200') != '200': alt_error = 'error getting playlists,' \ ' but no error message found' self._log.warn( playlists.attrib.get('message', alt_error)) return for name in self.config['playlist_names'].as_str_seq(): for playlist in playlists: if name == playlist.attrib['name']: ids.append(playlist.attrib['id']) playlist_dict = self.get_playlists(ids) # delete old tags if self.config['delete']: existing = list(lib.items('subsonic_playlist:";"')) to_be_removed = filter_to_be_removed( existing, playlist_dict.keys()) for item in to_be_removed: item['subsonic_playlist'] = '' with lib.transaction(): item.try_sync(write=True, move=False) self.update_tags(playlist_dict, lib) subsonicplaylist_cmds = Subcommand( 'subsonicplaylist', help=u'import a subsonic playlist' ) subsonicplaylist_cmds.parser.add_option( u'-d', u'--delete', action='store_true', help=u'delete tag from items not in any playlist anymore', ) subsonicplaylist_cmds.func = build_playlist return [subsonicplaylist_cmds]
def __init__(self): super(Drop2BeetsPlugin, self).__init__() self.attributes = None self.dropbox_path = self.config['dropbox_path'].as_filename() try: exec(self.config['on_item'].get(), globals()) self.on_item = on_item except: self.on_item = lambda item, path: dict() self._command_dropbox = Subcommand('dropbox', help="Start watching %s for files to import automatically" % self.dropbox_path) self._command_dropbox.func = self._main self._command_install = Subcommand('install_dropbox', help="Install drop2beets as a user-lever systemd service") self._command_install.func = self._install
def commands(self): thumbnails_command = Subcommand("thumbnails", help=u"Create album thumbnails") thumbnails_command.parser.add_option( u"-f", u"--force", dest="force", action="store_true", default=False, help=u"force regeneration of thumbnails deemed fine (existing & " u"recent enough)", ) thumbnails_command.parser.add_option( u"--dolphin", dest="dolphin", action="store_true", default=False, help=u"create Dolphin-compatible thumbnail information (for KDE)", ) thumbnails_command.func = self.process_query return [thumbnails_command]
def __init__(self): super(Rivendell2BeetsPlugin, self).__init__() self.attributes = None self.IDENTIFIED_VIA_ACOUSTID = 0 self.SEEN = 0 self.IMPORTED = 0 self.REJECTED = 0 self._command_rivendell = Subcommand('rivendell2beets', help="Import from rivendell") self._command_rivendell.func = self._main
def commands(self): """Add the alias commands.""" if self.config['from_path'].get(bool): commands = dict(self.get_path_commands()) else: commands = {} for alias in self.config['aliases'].keys(): if alias in commands: raise confuse.ConfigError( u'alias.aliases.{0} was specified multiple times'.format( alias)) command = self.config['aliases'][alias].get() if isinstance(command, six.text_type): commands[alias] = self.get_command(alias, command) elif isinstance(command, abc.Mapping): command_text = command.get('command') if not command_text: raise confuse.ConfigError( u'alias.aliases.{0}.command not found'.format(alias)) help_text = command.get('help', command_text) commands[alias] = self.get_command(alias, command_text, help_text) else: raise confuse.ConfigError( u'alias.aliases.{0} must be a string or single-element mapping' .format(alias)) if 'alias' in commands: raise ui.UserError( u'alias `alias` is reserved for the alias plugin') alias = Subcommand('alias', help=u'Print the available alias commands.') alias_commands = dict((a, c.command) for a, c in commands.items()) alias.func = lambda lib, opts, args: self.cmd_alias( lib, opts, args, alias_commands) commands['alias'] = alias return commands.values()
def commands(self): def init_server(lib, opts, args): model = BeetsModel(lib) if opts.username is None: raise KeyError('Username is required') if opts.password is None: raise KeyError('Password is required') # Get all the args and opts into one variable configs = { u'host': self.config['host'].as_str(), u'port': self.config['port'].get(int), u'cors': self.config['cors'].as_str(), u'playlist_dir': self.config['playlist_dir'].as_filename(), u'debug': opts.debug, u'username': opts.username, u'password': opts.password, u'ignoredArticles': self.config['ignoredArticles'].as_str(), } app = SubsonicServer(model, configs, __name__) app.run( host=configs[u'host'], port=configs[u'port'], debug=configs[u'debug'], ) cmd = Subcommand('sonic', help='Run Subsonic server interface for beets') cmd.parser.add_option(u'-u', u'--username', action='store', help=u'username') cmd.parser.add_option(u'-p', u'--password', action='store', help=u'password') cmd.parser.add_option(u'-d', u'--debug', action='store_true', default=False, help=u'debug mode') cmd.func = init_server return [cmd]
def commands(self): gupload = Subcommand('gmusic-upload', help=u'upload your tracks to Google Play Music') gupload.func = self.upload search = Subcommand('gmusic-songs', help=u'list of songs in Google Play Music library') search.parser.add_option('-t', '--track', dest='track', action='store_true', help='Search by track name') search.parser.add_option('-a', '--artist', dest='artist', action='store_true', help='Search by artist') search.func = self.search return [gupload, search]
def commands(self): """Add the commands.""" write_advisory = Subcommand('write-advisory', help=u'write the advisory state to tags') write_advisory.parser.add_option( u'-p', u'--pretend', action='store_true', help=u"show all changes but do nothing" ) write_advisory.func = self.write_advisory read_advisory = Subcommand('read-advisory', help=u'read the advisory state from tags') read_advisory.parser.add_option( u'-p', u'--pretend', action='store_true', help=u"show all changes but do nothing" ) read_advisory.func = self.read_advisory return [read_advisory, write_advisory]
if re.match(UUID_REGEX, aid): album_ids.append(aid) else: log.info(u'skipping invalid MBID: {0}', aid) # Submit to MusicBrainz. print('Updating MusicBrainz collection {0}...'.format(collection_id)) submit_albums(collection_id, album_ids) print('...MusicBrainz collection updated.') def update_collection(lib, opts, args): update_album_list(lib.albums()) update_mb_collection_cmd = Subcommand('mbupdate', help='Update MusicBrainz collection') update_mb_collection_cmd.func = update_collection class MusicBrainzCollectionPlugin(BeetsPlugin): def __init__(self): super(MusicBrainzCollectionPlugin, self).__init__() musicbrainzngs.auth( config['musicbrainz']['user'].get(unicode), config['musicbrainz']['pass'].get(unicode), ) self.config.add({'auto': False}) if self.config['auto']: self.import_stages = [self.imported] def commands(self):
def commands(self): pastan = Subcommand('pastan', help='Hello, my name is pastan.') pastan.func = self.pastan return [pastan]
def commands(self): freedesktop_command = Subcommand("freedesktop", help="Create .directory files") freedesktop_command.func = self.process_query return [freedesktop_command]
def make_command(name, func, **kwargs): c = Subcommand(name, **kwargs) c.func = func return c
def __init__(self): super(DuplicatesPlugin, self).__init__() self.config.add({ 'album': False, 'checksum': '', 'copy': '', 'count': False, 'delete': False, 'format': '', 'full': False, 'keys': [], 'merge': False, 'move': '', 'path': False, 'tiebreak': {}, 'strict': False, 'tag': '', }) self._command = Subcommand('duplicates', help=__doc__, aliases=['dup']) self._command.parser.add_option( u'-c', u'--count', dest='count', action='store_true', help=u'show duplicate counts', ) self._command.parser.add_option( u'-C', u'--checksum', dest='checksum', action='store', metavar='PROG', help=u'report duplicates based on arbitrary command', ) self._command.parser.add_option( u'-d', u'--delete', dest='delete', action='store_true', help=u'delete items from library and disk', ) self._command.parser.add_option( u'-F', u'--full', dest='full', action='store_true', help=u'show all versions of duplicate tracks or albums', ) self._command.parser.add_option( u'-s', u'--strict', dest='strict', action='store_true', help=u'report duplicates only if all attributes are set', ) self._command.parser.add_option( u'-k', u'--key', action='append', metavar='KEY', help=u'report duplicates based on keys (use multiple times)', ) self._command.parser.add_option( u'-M', u'--merge', dest='merge', action='store_true', help=u'merge duplicate items', ) self._command.parser.add_option( u'-m', u'--move', dest='move', action='store', metavar='DEST', help=u'move items to dest', ) self._command.parser.add_option( u'-o', u'--copy', dest='copy', action='store', metavar='DEST', help=u'copy items to dest', ) self._command.parser.add_option( u'-t', u'--tag', dest='tag', action='store', help=u'tag matched items with \'k=v\' attribute', ) self._command.parser.add_all_common_options()
def commands(self): mbupdate = Subcommand('mbupdate', help='Update MusicBrainz collection') mbupdate.func = self.update_collection return [mbupdate]
selected_artists[random.choice(artists)] += 1 objs = [] for artist, count in selected_artists.items(): objs_from_artist = objs_by_artists[artist] number = min(count, len(objs_from_artist)) objs.extend(random.sample(objs_from_artist, number)) else: number = min(len(objs), opts.number) objs = random.sample(objs, number) for item in objs: print_obj(item, lib, template) random_cmd = Subcommand('random', help='chose a random track or album') random_cmd.parser.add_option('-a', '--album', action='store_true', help='choose an album instead of track') random_cmd.parser.add_option('-p', '--path', action='store_true', help='print the path of the matched item') random_cmd.parser.add_option('-f', '--format', action='store', help='print with custom format', default=None) random_cmd.parser.add_option('-n', '--number', action='store', type="int", help='number of objects to choose', default=1) random_cmd.parser.add_option('-e', '--equal-chance', action='store_true', help='each artist has the same chance') random_cmd.func = random_item class Random(BeetsPlugin): def commands(self): return [random_cmd]
def commands(self): play_command = Subcommand("play", help="send music to a player as a playlist") play_command.parser.add_album_option() play_command.parser.add_option("-A", "--args", action="store", help="add additional arguments to the command") play_command.func = self.play_music return [play_command]
# the following conditions: # # The above copyright notice and this permission notice shall be # included in all copies or substantial portions of the Software. """Beets command line interface to cmus-remote an instance of cmus must already be running""" from beets.plugins import BeetsPlugin from beets import mediafile from beets import ui from beets.ui import Subcommand from beets.util import syspath, normpath import subprocess cmus_cmd = Subcommand('cmus', help='Interface to a remote cmus instance.') cmus_cmd.parser.add_option('--socket', action='store_true', dest='socket', help='Connect using socket SOCKET instead of ~/.cmus/socket.') cmus_cmd.parser.add_option('-p', '--play', action='store_true', help='Start playing.') cmus_cmd.parser.add_option('-u', '--pause', action='store_true', help='Toggle pause.') cmus_cmd.parser.add_option('-s', '--stop', action='store_true', help='Stop playing.') cmus_cmd.parser.add_option('-n', '--next', action='store_true', help='Skip forward in playlist.') cmus_cmd.parser.add_option('-r', '--prev', action='store_true', help='Skip backward in playlist.') cmus_cmd.parser.add_option('-R', '--repeat', action='store_true', help='Toggle repeat.') cmus_cmd.parser.add_option('-S', '--shuffle', action='store_true', help='Toggle shuffle.') cmus_cmd.parser.add_option('-Q', '--status', action='store_true', help='Get player status information.') cmus_cmd.parser.add_option('-l', '--library', action='store_true', help='Modify library instead of playlist.') cmus_cmd.parser.add_option('-P', '--playlist', action='store_true', help='Modify playlist (default).') cmus_cmd.parser.add_option('-q', '--queue', action='store_true', help='Modify play queue instead of playlist.') cmus_cmd.parser.add_option('-c', '--clear', action='store_true', help='clear playlist, library (-l) or play queue (-q) before adding songs.') cmus_cmd.parser.add_option('-a', '--add', action='store_true', help='Add songs to cmus. Similar to beet ls (see beet help ls).')
def commands(self): bad_command = Subcommand('bad', help='check for corrupt or missing files') bad_command.func = self.check_bad return [bad_command]
def commands(self): """ Commands for generating and importing features """ def get_mfcc(song): # Deferred import (librosa was messing up general beet output) import librosa y, sr = librosa.load(song.encode(sys.getfilesystemencoding())) mfcc = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=20) return block_reduce(mfcc, (1, 100), np.mean) # Generate sequential features features_cmd = Subcommand( "features", help="Generate sequential acoustic features [blackbird]") def features_func(lib, opts, args): filtered_items = lib.items(decargs(args)) if len(filtered_items) == 0: print("Query didn't match any item") return seq_features_file = config["blackbird"]["features"].get("unicode") seq_features = cPickle.load(open(seq_features_file, "rb")) print("Finding features...") bar = pyprind.ProgBar(len(filtered_items)) for item in filtered_items: if item.id not in features: try: data = get_mfcc(item.path) seq_features[item.id] = data except Exception as e: print(e) bar.update() print("Saving data...") cPickle.dump(seq_features, open(seq_features_file, "wb"), protocol=cPickle.HIGHEST_PROTOCOL) # Import features as coordinates coords_cmd = Subcommand( "coords", help= "Generate coordinates based on calculated features [blackbird]") coords_cmd.parser.add_option( "-t", "--type", help="Type of vectorization [mean (default), lstm]") def coords_func(lib, opts, args): if opts.type: seq_features_file = config["blackbird"]["features"].get( "unicode") seq_features = cPickle.load(open(seq_features_file, "rb")) keys = seq_features.keys() if opts.type == "mean": features = np.empty((len(seq_features), 20)) for idx, key in enumerate(seq_features): length = seq_features[key].shape[1] features[idx, :] = seq_features[key][:, int( 0.1 * length):int(0.9 * length)].mean(axis=1) elif opts.type == "lstm": print("Loading network...") model = LSTMSeq2Seq( config["blackbird"]["model"]["arch"].get("unicode"), config["blackbird"]["model"]["weights"].get("unicode"), config["blackbird"]["model"]["output"].get()) # Pad sequences maxlen = 150 padded_seq_features = np.empty((len(seq_features), maxlen, 20)) for idx, key in enumerate(seq_features): padded_seq_features[ idx, :, :] = sequence.pad_sequences( seq_features[key], maxlen=maxlen, dtype="float32").T print("Getting vectors...") features = model.predict([padded_seq_features, 0]) else: print("Provide a valid --type [mean, lstm]") sys.exit(1) print("Reducing dimensions...") features_2d = TSNE(n_components=2).fit_transform(features) print("Writing to db...") conn = sqlite3.connect(config["blackbird"]["db"].get( "unicode")) cur = conn.cursor() cur.execute("DELETE FROM coords") to_insert = [] for idx in xrange(features_2d.shape[0]): to_insert.append((keys[idx], features_2d[idx, 0], features_2d[idx, 1])) cur.executemany("INSERT INTO coords VALUES (?, ?, ?)", to_insert) conn.commit() conn.close() # Fill leftovers ids_to_fill = [] for item in lib.items(): if item.id not in keys: ids_to_fill.append(item.id) self.fill(ids_to_fill, features_2d.min(axis=0), features_2d.max(axis=0)) else: print("Provide a valid --type [mean, lstm]") coords_cmd.func = coords_func features_cmd.func = features_func return [features_cmd, coords_cmd]
# found duplicates if opts["output_count"]: print_obj(match_list[0], lib, fmt=fmt.format(num)) else: for match in match_list: print_obj(match, lib, fmt=fmt.format(num)) print "" ####################### # Command Declaration # ####################### find_command = Subcommand( 'find_duplicates', help = 'Lists all duplicates for given query', aliases = ["fdup"] ) find_command.func = dupl_finder gen_parser(find_command) ##################### # Plugin Definition # ##################### class ExtendedDuplicateFinder(BeetsPlugin): def commands(self): return [find_command]
import beets import urllib import urllib2 def sendAlbums(username, password, albumIds): url = 'http://musicbrainz.org/ws/1/collection/' #Where to send them data = urllib.urlencode({ 'add': ",".join(albumIds) }) #Post it pm = urllib2.HTTPPasswordMgrWithDefaultRealm() pm.add_password(None, url, username, password) urllib2.install_opener(urllib2.build_opener( urllib2.HTTPDigestAuthHandler(pm))) resp = urllib2.urlopen(url, data).read() return resp update_mb_collection = Subcommand('mbupdate', help='Update MusicBrainz collection') def updateCollection(lib, config, opts, args): username = beets.ui.config_val(config, 'musicbrainz', 'user', '') password = beets.ui.config_val(config, 'musicbrainz', 'pass', '') #Get a list of all the albums albums = map(lambda a: a.mb_albumid, lib.albums()) print 'Updating MusicBrainz collection...' sendAlbums(username, password, albums) print '...MusicBrainz collection updated' update_mb_collection.func = updateCollection class MusicbrainzCollection(BeetsPlugin): def commands(self): return [update_mb_collection]
""" This plugin creates a separate log of files that are ignored when on import and a separate log is created for them """ from beets.plugins import BeetsPlugin import os import socket from beets import config from beets.ui import Subcommand missedLogFile = '/home/travis/Apps/BeetsPlugin/beetsplug/missed.txt' importMissedAlbums = Subcommand('importmissed', help='Import the album listed in the "missed" file') def reImportMissed(lib, opts, args): print "Reimported files/albums we missed the first time" with open(missedLogFile) as f: albums = f.readlines() importMissedAlbums.func = reImportMissedAlbums class MissedOnImport(BeetsPlugin): def __init__(self): print 'Init of new plugin!!'
from mutagen.flac import ( FLAC, Padding, MetadataBlock, VCFLACDict, CueSheet, SeekTable, FLACNoHeaderError, FLACVorbisError, ) from mutagen.id3 import ID3, BitPaddedInt, MakeID3v1 from mutagen._util import insert_bytes PATH_FORMAT = "$artist/$album ($year) [$format_upper]/" "$track - $artist - $title.$format" beetFs_command = Subcommand("mount", help="Mount a beets filesystem") log = logging.getLogger("beets") # FUSE version at the time of writing. Be compatible with this version. fuse.fuse_python_api = (0, 2) """ This is duplicated from Library. Ideally should be exposed from there.""" METADATA_RW_FIELDS = [ ("title", "text"), ("artist", "text"), ("album", "text"), ("genre", "text"), ("composer", "text"), ("grouping", "text"), ("year", "int"),
for item in items: usertags = item.get('usertags', None) if usertags is None: usertags = [] else: usertags = usertags.split('|') # usertags.append(' '.join(newtags)) usertags.extend(newtags) usertags = list(set(usertags)) if '' in usertags: usertags.pop(usertags.index('')) item.update({'usertags': '|'.join(usertags)}) item.store() print('Added tags\n {}'.format(item)) add_tag_command = Subcommand( 'addtag', help='Add user defined tags.', aliases=('adt',)) add_tag_command.func = add_usertag add_tag_command.parser.add_option( '--tag', '-t', action='append', dest='tags', help='Tag to add. ' 'Combine multiple tags by specifiing this option repeatedly.') add_tag_command.parser.usage += '\n'\ 'Example: beet addtag artist:beatles -t favourites' def remove_usertag(lib, opts, args): """Remove a usertag""" items = lib.items(args) deltags = opts.tags
if opts.album: objs = lib.albums() else: objs = lib.items() items = filter(lambda i: is_match(queryMatcher, i, album=opts.album, threshold=threshold), objs) for item in items: print_obj(item, lib, template) if opts.verbose: print(is_match(queryMatcher, item, album=opts.album, verbose=True)[1]) fuzzy_cmd = Subcommand('fuzzy', help='list items using fuzzy matching') fuzzy_cmd.parser.add_option('-a', '--album', action='store_true', help='choose an album instead of track') fuzzy_cmd.parser.add_option('-p', '--path', action='store_true', help='print the path of the matched item') fuzzy_cmd.parser.add_option('-f', '--format', action='store', help='print with custom format', default=None) fuzzy_cmd.parser.add_option('-v', '--verbose', action='store_true', help='output scores for matches') fuzzy_cmd.parser.add_option('-t', '--threshold', action='store', help='return result with a fuzzy score above threshold. \ (default is 0.7)', default=None) fuzzy_cmd.func = fuzzy_list class Fuzzy(BeetsPlugin):
def update_collection(lib, opts, args): # Get the collection to modify. collections = mb_request('collection', 'GET', True, True) if not collections['collection-list']: raise ui.UserError('no collections exist for user') collection_id = collections['collection-list'][0]['id'] # Get a list of all the albums. albums = [a.mb_albumid for a in lib.albums() if a.mb_albumid] # Submit to MusicBrainz. print('Updating MusicBrainz collection {0}...'.format(collection_id)) submit_albums(collection_id, albums) print('...MusicBrainz collection updated.') update_mb_collection_cmd = Subcommand('mbupdate', help='Update MusicBrainz collection') update_mb_collection_cmd.func = update_collection class MusicBrainzCollectionPlugin(BeetsPlugin): def __init__(self): super(MusicBrainzCollectionPlugin, self).__init__() musicbrainzngs.auth( config['musicbrainz']['user'].get(unicode), config['musicbrainz']['pass'].get(unicode), ) def commands(self): return [update_mb_collection_cmd]
genres = {} def reverse_dict(orig): reverse = {} for (genre, artists) in orig.items(): for artist in artists: reverse[artist]=genre return reverse def get_genre(artist, genre_dict): try: return genre_dict[artist] except KeyError: return None update_cmd = Subcommand('update-genres', help='Update the genres of all media in library acording to the current genre list file') def update_genres(lib, config, opts, args): global genres global fallback_str for item in lib.items(ui.decargs(args)): if item.album_id is not None: continue genre = get_genre(item.artist, genres) log.warn("title: %s, artist: %s, genre: %s" % (item.title, item.artist, genre)) if not genre and fallback_str != None: genre = fallback_str log.warn(u'no genre for %s in list: fallback to %s' % (item.artist, genre)) if genre is not None: log.warn(u'adding genre for %s from list: %s' % (item.artist, genre)) item.genre = genre lib.store(item)