hooke/plugin/playlist.py

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