hooke/plugin/playlist.py

   1 # Copyright (C) 2010 W. Trevor King <wking@drexel.edu>
   2 #
   3 # This file is part of Hooke.
   4 #
   5 # Hooke is free software: you can redistribute it and/or modify it
   6 # under the terms of the GNU Lesser General Public License as
   7 # published by the Free Software Foundation, either version 3 of the
   8 # License, or (at your option) any later version.
   9 #
  10 # Hooke is distributed in the hope that it will be useful, but WITHOUT
  11 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  12 # or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General
  13 # Public License for more details.
  14 #
  15 # You should have received a copy of the GNU Lesser General Public
  16 # License along with Hooke.  If not, see
  17 # <http://www.gnu.org/licenses/>.
  18
  19 """The ``playlist`` module provides :class:`PlaylistPlugin` and
  20 several associated :class:`hooke.command.Command`\s for handling
  21 :mod:`hooke.playlist` classes.
  22 """
  23
  24 import glob
  25 import logging
  26 import os.path
  27
  28 from ..command import Command, Argument, Failure
  29 from ..curve import NotRecognized
  30 from ..playlist import load
  31 from ..util.itertools import reverse_enumerate
  32 from . import Builtin
  33
  34
  35 class PlaylistPlugin (Builtin):
  36     def __init__(self):
  37         super(PlaylistPlugin, self).__init__(name='playlist')
  38         self._commands = [
  39             NextCommand(self), PreviousCommand(self), JumpCommand(self),
  40             GetCommand(self), IndexCommand(self), CurveListCommand(self),
  41             SaveCommand(self), LoadCommand(self),
  42             AddCommand(self), AddGlobCommand(self),
  43             RemoveCommand(self), ApplyCommand(self),
  44             FilterCommand(self),
  45             ]
  46
  47
  48 # Define common or complicated arguments
  49
  50 def current_playlist_callback(hooke, command, argument, value):
  51     if value != None:
  52         return value
  53     playlist = hooke.playlists.current()
  54     if playlist == None:
  55         raise Failure('No playlists loaded')
  56     return playlist
  57
  58 PlaylistArgument = Argument(
  59     name='playlist', type='playlist', callback=current_playlist_callback,
  60     help="""
  61 :class:`hooke.playlist.Playlist` to act on.  Defaults to the current
  62 playlist.
  63 """.strip())
  64
  65 def playlist_name_callback(hooke, command, argument, value):
  66     if value != None:
  67         return value
  68     i = 0
  69     names = [p.name for p in hooke.playlists]
  70     while True:
  71         name = 'playlist-%d' % i
  72         if name not in names:
  73             return name
  74         i += 1
  75
  76 PlaylistNameArgument = Argument(
  77     name='output playlist', type='string', optional=True,
  78     callback=playlist_name_callback,
  79     help="""
  80 Name of the new playlist (defaults to an auto-generated name).
  81 """.strip())
  82
  83 def all_drivers_callback(hooke, command, argument, value):
  84     return hooke.drivers
  85
  86
  87 # Define useful command subclasses
  88
  89 class PlaylistCommand (Command):
  90     """A :class:`~hooke.command.Command` operating on a
  91     :class:`~hooke.playlist.Playlist`.
  92     """
  93     def __init__(self, **kwargs):
  94         if 'arguments' in kwargs:
  95             kwargs['arguments'].insert(0, PlaylistArgument)
  96         else:
  97             kwargs['arguments'] = [PlaylistArgument]
  98         super(PlaylistCommand, self).__init__(**kwargs)
  99
 100     def _playlist(self, hooke, params):
 101         """Get the selected playlist.
 102
 103         Notes
 104         -----
 105         `hooke` is intended to attach the selected playlist to the
 106         local hooke instance; the returned playlist should not be
 107         effected by the state of `hooke`.
 108         """
 109         # HACK? rely on params['playlist'] being bound to the local
 110         # hooke (i.e. not a copy, as you would get by passing a
 111         # playlist through the queue).  Ugh.  Stupid queues.  As an
 112         # alternative, we could pass lookup information through the
 113         # queue...
 114         return params['playlist']
 115
 116
 117 class PlaylistAddingCommand (Command):
 118     """A :class:`~hooke.command.Command` adding a
 119     :class:`~hooke.playlist.Playlist`.
 120     """
 121     def __init__(self, **kwargs):
 122         if 'arguments' in kwargs:
 123             kwargs['arguments'].insert(0, PlaylistNameArgument)
 124         else:
 125             kwargs['arguments'] = [PlaylistNameArgument]
 126         super(PlaylistAddingCommand, self).__init__(**kwargs)
 127
 128     def _set_playlist(self, hooke, params, playlist):
 129         """Attach a new playlist.
 130         """
 131         playlist_names = [p.name for p in hooke.playlists]
 132         if playlist.name in playlist_names or playlist.name == None:
 133             playlist.name = params['output playlist']  # HACK: override input name.  How to tell if it is callback-generated?
 134         hooke.playlists.append(playlist)
 135
 136
 137 # Define commands
 138
 139 class NextCommand (PlaylistCommand):
 140     """Move playlist to the next curve.
 141     """
 142     def __init__(self, plugin):
 143         super(NextCommand, self).__init__(
 144             name='next curve', help=self.__doc__, plugin=plugin)
 145
 146     def _run(self, hooke, inqueue, outqueue, params):
 147         self._playlist(hooke, params).next()
 148
 149
 150 class PreviousCommand (PlaylistCommand):
 151     """Move playlist to the previous curve.
 152     """
 153     def __init__(self, plugin):
 154         super(PreviousCommand, self).__init__(
 155             name='previous curve', help=self.__doc__, plugin=plugin)
 156
 157     def _run(self, hooke, inqueue, outqueue, params):
 158         self._playlist(hooke, params).previous()
 159
 160
 161 class JumpCommand (PlaylistCommand):
 162     """Move playlist to a given curve.
 163     """
 164     def __init__(self, plugin):
 165         super(JumpCommand, self).__init__(
 166             name='jump to curve',
 167             arguments=[
 168                 Argument(name='index', type='int', optional=False, help="""
 169 Index of target curve.
 170 """.strip()),
 171                 ],
 172             help=self.__doc__, plugin=plugin)
 173
 174     def _run(self, hooke, inqueue, outqueue, params):
 175         self._playlist(hooke, params).jump(params['index'])
 176
 177
 178 class IndexCommand (PlaylistCommand):
 179     """Print the index of the current curve.
 180
 181     The first curve has index 0.
 182     """
 183     def __init__(self, plugin):
 184         super(IndexCommand, self).__init__(
 185             name='curve index', help=self.__doc__, plugin=plugin)
 186
 187     def _run(self, hooke, inqueue, outqueue, params):
 188         outqueue.put(self._playlist(hooke, params).index())
 189
 190
 191 class GetCommand (PlaylistCommand):
 192     """Return a :class:`hooke.playlist.Playlist`.
 193     """
 194     def __init__(self, plugin):
 195         super(GetCommand, self).__init__(
 196             name='get playlist', help=self.__doc__, plugin=plugin)
 197
 198     def _run(self, hooke, inqueue, outqueue, params):
 199         outqueue.put(self._playlist(hooke, params))
 200
 201
 202 class CurveListCommand (PlaylistCommand):
 203     """Get the curves in a playlist.
 204     """
 205     def __init__(self, plugin):
 206         super(CurveListCommand, self).__init__(
 207             name='playlist curves', help=self.__doc__, plugin=plugin)
 208
 209     def _run(self, hooke, inqueue, outqueue, params):
 210         outqueue.put(list(self._playlist(hooke, params)))
 211
 212
 213 class SaveCommand (PlaylistCommand):
 214     """Save a playlist.
 215     """
 216     def __init__(self, plugin):
 217         super(SaveCommand, self).__init__(
 218             name='save playlist',
 219             arguments=[
 220                 Argument(name='output', type='file',
 221                          help="""
 222 File name for the output playlist.  Defaults to overwriting the input
 223 playlist.  If the playlist does not have an input file (e.g. it was
 224 created from scratch with 'new playlist'), this option is required.
 225 """.strip()),
 226                 ],
 227             help=self.__doc__, plugin=plugin)
 228
 229     def _run(self, hooke, inqueue, outqueue, params):
 230         self._playlist(hooke, params).save(params['output'])
 231
 232
 233 class LoadCommand (PlaylistAddingCommand):
 234     """Load a playlist.
 235     """
 236     def __init__(self, plugin):
 237         super(LoadCommand, self).__init__(
 238             name='load playlist',
 239             arguments=[
 240                 Argument(name='input', type='file', optional=False,
 241                          help="""
 242 File name for the input playlist.
 243 """.strip()),
 244                 Argument(name='drivers', type='driver', optional=True,
 245                          count=-1, callback=all_drivers_callback,
 246                          help="""
 247 Drivers for loading curves.
 248 """.strip()),
 249                 ],
 250             help=self.__doc__, plugin=plugin)
 251
 252     def _run(self, hooke, inqueue, outqueue, params):
 253         p = load(path=params['input'], drivers=params['drivers'], hooke=hooke)
 254         self._set_playlist(hooke, params, p)
 255         outqueue.put(p)
 256
 257
 258 class AddCommand (PlaylistCommand):
 259     """Add a curve to a playlist.
 260     """
 261     def __init__(self, plugin):
 262         super(AddCommand, self).__init__(
 263             name='add curve to playlist',
 264             arguments=[
 265                 Argument(name='input', type='file', optional=False,
 266                          help="""
 267 File name for the input :class:`hooke.curve.Curve`.
 268 """.strip()),
 269                 Argument(name='info', type='dict', optional=True,
 270                          help="""
 271 Additional information for the input :class:`hooke.curve.Curve`.
 272 """.strip()),
 273                 ],
 274             help=self.__doc__, plugin=plugin)
 275
 276     def _run(self, hooke, inqueue, outqueue, params):
 277         self._playlist(hooke, params).append_curve_by_path(
 278             params['input'], params['info'], hooke=hooke)
 279
 280
 281 class AddGlobCommand (PlaylistCommand):
 282     """Add curves to a playlist with file globbing.
 283
 284     Adding lots of files one at a time can be tedious.  With this
 285     command you can use globs (`data/curves/*.dat`) to add curves
 286     for all matching files at once.
 287     """
 288     def __init__(self, plugin):
 289         super(AddGlobCommand, self).__init__(
 290             name='glob curves to playlist',
 291             arguments=[
 292                 Argument(name='input', type='string', optional=False,
 293                          help="""
 294 File name glob for the input :class:`hooke.curve.Curve`.
 295 """.strip()),
 296                 Argument(name='info', type='dict', optional=True,
 297                          help="""
 298 Additional information for the input :class:`hooke.curve.Curve`.
 299 """.strip()),
 300                 ],
 301             help=self.__doc__, plugin=plugin)
 302
 303     def _run(self, hooke, inqueue, outqueue, params):
 304         p = self._playlist(hooke, params)
 305         for path in sorted(glob.glob(params['input'])):
 306             try:
 307                 p.append_curve_by_path(path, params['info'], hooke=hooke)
 308             except NotRecognized, e:
 309                 log = logging.getLogger('hooke')
 310                 log.warn(unicode(e))
 311                 continue
 312             outqueue.put(p[-1])
 313
 314 class RemoveCommand (PlaylistCommand):
 315     """Remove a curve from a playlist.
 316     """
 317     def __init__(self, plugin):
 318         super(RemoveCommand, self).__init__(
 319             name='remove curve from playlist',
 320             arguments=[
 321                 Argument(name='index', type='int', optional=False, help="""
 322 Index of target curve.
 323 """.strip()),
 324                 ],
 325             help=self.__doc__, plugin=plugin)
 326
 327     def _run(self, hooke, inqueue, outqueue, params):
 328         self._playlist(hooke, params).pop(params['index'])
 329         self._playlist(hooke, params).jump(params.index())
 330
 331
 332 class ApplyCommand (PlaylistCommand):
 333     """Apply a :class:`~hooke.command_stack.CommandStack` to each
 334     curve in a playlist.
 335
 336     TODO: discuss `evaluate`.
 337     """
 338     def __init__(self, plugin):
 339         super(ApplyCommand, self).__init__(
 340             name='apply command stack to playlist',
 341             arguments=[
 342                 Argument(name='commands', type='command stack',
 343                          help="""
 344 Command stack to apply to each curve.  Defaults to the `command_stack`
 345 plugin's current stack.
 346 """.strip()),
 347                 Argument(name='evaluate', type='bool', default=False,
 348                          help="""
 349 Evaluate the applied command stack immediately.
 350 """.strip()),
 351                 ],
 352             help=self.__doc__, plugin=plugin)
 353
 354     def _run(self, hooke, inqueue, outqueue, params):
 355         params = self.__setup_params(hooke=hooke, params=params)
 356         p = self._playlist(hooke, params)
 357         if params['evaluate'] == True:
 358             exec_cmd = hooke.command_by_name['execute command stack']
 359             for curve in p.items():
 360                 hooke.run_command(exec_cmd.name,
 361                                   {'commands':params['commands'],
 362                                    'stack':True})
 363         else:
 364             for curve in p:
 365                 for command in params['commands']:
 366                     curve.command_stack.append(command)
 367                 curve.set_hooke(hooke)
 368                 curve.unload()
 369
 370     def __setup_params(self, hooke, params):
 371         if params['commands'] == None:
 372             cstack_plugin = [p for p in hooke.plugins
 373                              if p.name == 'command_stack'][0]
 374             params['commands'] = cstack_plugin.command_stack
 375         return params
 376
 377
 378 class FilterCommand (PlaylistAddingCommand, PlaylistCommand):
 379     """Create a subset playlist via a selection function.
 380
 381     Removing lots of curves one at a time can be tedious.  With this
 382     command you can use a function `filter` to select the curves you
 383     wish to keep.
 384
 385     Notes
 386     -----
 387     There are issues with pickling functions bound to class
 388     attributes, because the pickle module doesn't know where those
 389     functions were originally defined (where it should point the
 390     loader).  Because of this, subclasses with hard-coded filter
 391     functions are encouraged to define their filter function as a
 392     method of their subclass.  See, for example,
 393     :meth:`NoteFilterCommand.filter`.
 394     """
 395     def __init__(self, plugin, name='filter playlist', load_curves=True):
 396         super(FilterCommand, self).__init__(
 397             name=name, help=self.__doc__, plugin=plugin)
 398         self._load_curves = load_curves
 399         if not hasattr(self, 'filter'):
 400             self.arguments.append(
 401                 Argument(name='filter', type='function', optional=False,
 402                          help="""
 403 Function returning `True` for "good" curves.
 404 `filter(curve, hooke, inqueue, outqueue, params) -> True/False`.
 405 """.strip()))
 406
 407     def _run(self, hooke, inqueue, outqueue, params):
 408         if not hasattr(self, 'filter'):
 409             filter_fn = params['filter']
 410         else:
 411             filter_fn = self.filter
 412         p = self._playlist(hooke, params).filter(
 413             filter_fn, load_curves=self._load_curves,
 414             hooke=hooke, inqueue=inqueue, outqueue=outqueue, params=params)
 415         self._set_playlist(hooke, params, p)
 416         if hasattr(p, 'path') and p.path != None:
 417             p.set_path(os.path.join(os.path.dirname(p.path), p.name))
 418         outqueue.put(p)