hooke/plugin/playlist.py

   1 """Defines :class:`PlaylistPlugin` several associated
   2 :class:`hooke.plugin.Command`\s for handling :mod:`hooke.playlist`
   3 classes.
   4 """
   5
   6 from ..playlist import FilePlaylist
   7 from ..plugin import Builtin, Command, Argument
   8
   9
  10 class PlaylistPlugin (Builtin):
  11     def __init__(self):
  12         super(PlaylistPlugin, self).__init__(name='playlist')
  13
  14     def commands(self):
  15         return [NextCommand(), PreviousCommand(), JumpCommand(),
  16                 SaveCommand(), LoadCommand(),
  17                 AddCommand(), RemoveCommand(), FilterCommand()]
  18
  19 class NextCommand (Command):
  20     """Move playlist to the next curve.
  21     """
  22     def __init__(self):
  23         super(NextCommand, self).__init__(
  24             name='next curve',
  25             arguments=[
  26                 Argument(name='playlist', type='playlist', optional=False,
  27                          help="""
  28 :class:``hooke.plugin.playlist.Playlist`` to act on.
  29 """.strip()),
  30                 ],
  31             help=self.__doc__)
  32
  33     def _run(inqueue, outqueue, params):
  34         params['playlist'].next()
  35
  36 class PreviousCommand (Command):
  37     """Move playlist to the previous curve.
  38     """
  39     def __init__(self):
  40         super(PreviousCommand, self).__init__(
  41             name='previous curve',
  42             arguments=[
  43                 Argument(name='playlist', type='playlist', optional=False,
  44                          help="""
  45 :class:``hooke.plugin.playlist.Playlist`` to act on.
  46 """.strip()),
  47                 ],
  48             help=self.__doc__)
  49
  50     def _run(inqueue, outqueue, params):
  51         params['playlist'].previous()
  52
  53 class JumpCommand (Command):
  54     """Move playlist to a given curve.
  55     """
  56     def __init__(self):
  57         super(JumpCommand, self).__init__(
  58             name='jump to curve',
  59             arguments=[
  60                 Argument(name='playlist', type='playlist', optional=False,
  61                          help="""
  62 :class:``hooke.plugin.playlist.Playlist`` to act on.
  63 """.strip()),
  64                 Argument(name='index', type='int', optional=False, help="""
  65 Index of target curve.
  66 """.strip()),
  67                 ],
  68             help=self.__doc__)
  69
  70     def _run(inqueue, outqueue, params):
  71         params['playlist'].jump(params['index'])
  72
  73 class SaveCommand (Command):
  74     """Save a playlist.
  75     """
  76     def __init__(self):
  77         super(SaveCommand, self).__init__(
  78             name='save playlist',
  79             arguments=[
  80                 Argument(name='playlist', type='playlist', optional=False,
  81                          help="""
  82 :class:``hooke.plugin.playlist.Playlist`` to act on.
  83 """.strip()),
  84                 Argument(name='output', type='file',
  85                          help="""
  86 File name for the output playlist.  Defaults to overwring the input
  87 playlist.
  88 """.strip()),
  89                 ],
  90             help=self.__doc__)
  91
  92     def _run(inqueue, outqueue, params):
  93         params['playlist'].save(params['output'])
  94
  95 class LoadCommand (Command):
  96     """Load a playlist.
  97     """
  98     def __init__(self):
  99         super(LoadCommand, self).__init__(
 100             name='load playlist',
 101             arguments=[
 102                 Argument(name='input', type='file', optional=False,
 103                          help="""
 104 File name for the input playlist.
 105 """.strip()),
 106                 Argument(name='digests', type='digest', optional=False,
 107                          count=-1,
 108                          help="""
 109 Digests for loading curves.
 110 """.strip()),
 111                 ],
 112             help=self.__doc__)
 113
 114     def _run(inqueue, outqueue, params):
 115         p = FilePlaylist(drivers=params['drivers'], path=params['input'])
 116         p.load()
 117         outqueue.put(p)
 118
 119 class AddCommand (Command):
 120     """Add a curve to a playlist.
 121     """
 122     def __init__(self):
 123         super(AddCommand, self).__init__(
 124             name='add curve to playlist',
 125             arguments=[
 126                 Argument(name='playlist', type='playlist', optional=False,
 127                          help="""
 128 :class:``hooke.plugin.playlist.Playlist`` to act on.
 129 """.strip()),
 130                 Argument(name='input', type='file', optional=False,
 131                          help="""
 132 File name for the input :class:`hooke.curve.Curve`.
 133 """.strip()),
 134                 Argument(name='info', type='dict', optional=True,
 135                          help="""
 136 Additional information for the input :class:`hooke.curve.Curve`.
 137 """.strip()),
 138                 ],
 139             help=self.__doc__)
 140
 141     def _run(inqueue, outqueue, params):
 142         params['playlist'].append_curve_by_path(params['input'],
 143                                                 params['info'])
 144
 145 class RemoveCommand (Command):
 146     """Remove a curve from a playlist.
 147     """
 148     def __init__(self):
 149         super(RemoveCommand, self).__init__(
 150             name='remove curve from playlist',
 151             arguments=[
 152                 Argument(name='playlist', type='playlist', optional=False,
 153                          help="""
 154 :class:``hooke.plugin.playlist.Playlist`` to act on.
 155 """.strip()),
 156                 Argument(name='index', type='int', optional=False, help="""
 157 Index of target curve.
 158 """.strip()),
 159                 ],
 160             help=self.__doc__)
 161
 162     def _run(inqueue, outqueue, params):
 163         params['playlist'].pop(params['index'])
 164         params['playlist'].jump(params._index)
 165
 166 class FilterCommand (Command):
 167     """Create a subset playlist via a selection function.
 168     """
 169     def __init__(self):
 170         super(FilterCommand, self).__init__(
 171             name='filter playlist',
 172             arguments=[
 173                 Argument(name='playlist', type='playlist', optional=False,
 174                          help="""
 175 :class:``hooke.plugin.playlist.Playlist`` to act on.
 176 """.strip()),
 177                 Argument(name='filter', type='function', optional=False,
 178                          help="""
 179 Function returning `True` for "good" curves.
 180 """.strip()),
 181                 ],
 182             help=self.__doc__)
 183
 184     def _run(inqueue, outqueue, params):
 185         p = params['playlist'].filter(params['filter'])
 186         outqueue.put(p)