X-Git-Url: http://git.tremily.us/?p=hooke.git;a=blobdiff_plain;f=hooke%2Fplugin%2Fcurve.py;h=821d33370e6051657cfdb298403e344d86430e5e;hp=e5a12aec3dc81971967f0f1920e53f080fca0348;hb=1fc27f9e070cf9667993e89ff7f43824fe66bd0c;hpb=09dfd027d5fc3ed0f9f262abab1fdb99508adc7e diff --git a/hooke/plugin/curve.py b/hooke/plugin/curve.py index e5a12ae..821d333 100644 --- a/hooke/plugin/curve.py +++ b/hooke/plugin/curve.py @@ -1,5 +1,5 @@ -# Copyright (C) 2008-2010 Alberto Gomez-Kasai -# Fabiano's Benedetti +# Copyright (C) 2008-2011 Alberto Gomez-Casado +# Fabrizio Benedetti # Massimo Sandal # W. Trevor King # @@ -25,29 +25,39 @@ associated :class:`hooke.command.Command`\s for handling """ import copy +import os.path +import re import numpy +import yaml from ..command import Command, Argument, Failure +from ..command_stack import CommandStack from ..curve import Data -from ..plugin import Builtin -from ..plugin.playlist import current_playlist_callback +from ..engine import CommandMessage from ..util.calculus import derivative from ..util.fft import unitary_avg_power_spectrum from ..util.si import ppSI, join_data_label, split_data_label +from . import Builtin +from .playlist import current_playlist_callback # Define common or complicated arguments -def current_curve_callback(hooke, command, argument, value): +def current_curve_callback(hooke, command, argument, value, load=True): if value != None: return value playlist = current_playlist_callback(hooke, command, argument, value) - curve = playlist.current() + curve = playlist.current(load=load) if curve == None: raise Failure('No curves in %s' % playlist) return curve +def unloaded_current_curve_callback(hooke, command, argument, value): + return current_curve_callback( + hooke=hooke, command=command, argument=argument, value=value, + load=False) + CurveArgument = Argument( name='curve', type='curve', callback=current_curve_callback, help=""" @@ -85,6 +95,15 @@ class CurveCommand (Command): super(CurveCommand, self).__init__(**kwargs) def _curve(self, hooke, params): + """Get the selected curve. + + Notes + ----- + `hooke` is intended to attach the selected curve to the local + playlist; the returned curve should not be effected by the + state of `hooke`. This is important for reliable + :class:`~hooke.command_stack.CommandStack`\s. + """ # HACK? rely on params['curve'] being bound to the local hooke # playlist (i.e. not a copy, as you would get by passing a # curve through the queue). Ugh. Stupid queues. As an @@ -92,6 +111,37 @@ class CurveCommand (Command): # queue... return params['curve'] + def _add_to_command_stack(self, params): + """Store the command name and current `params` values in the + curve's `.command_stack`. + + If this would duplicate the command currently on top of the + stack, no action is taken. Call early on, or watch out for + repeated param processing. + + Recommended practice is to *not* lock in argument values that + are loaded from the plugin's :attr:`.config`. + + Notes + ----- + Perhaps we should subclass :meth:`_run` and use :func:`super`, + or embed this in :meth:`run` to avoid subclasses calling this + method explicitly, with all the tedium and brittality that + implies. On the other hand, the current implemtnation allows + CurveCommands that don't effect the curve itself + (e.g. :class:`GetCommand`) to avoid adding themselves to the + stack entirely. + """ + if params['stack'] == True: + curve = self._curve(hooke=None, params=params) + if (len(curve.command_stack) > 0 + and curve.command_stack[-1].command == self.name + and curve.command_stack[-1].arguments == params): + pass # no need to place duplicate calls on the stack. + else: + curve.command_stack.append(CommandMessage( + self.name, dict(params))) + class BlockCommand (CurveCommand): """A :class:`CurveCommand` operating on a :class:`~hooke.curve.Data` block. @@ -216,9 +266,10 @@ class CurvePlugin (Builtin): def __init__(self): super(CurvePlugin, self).__init__(name='curve') self._commands = [ - GetCommand(self), InfoCommand(self), DeltaCommand(self), - ExportCommand(self), DifferenceCommand(self), - DerivativeCommand(self), PowerSpectrumCommand(self)] + GetCommand(self), InfoCommand(self), BlockInfoCommand(self), + DeltaCommand(self), ExportCommand(self), DifferenceCommand(self), + DerivativeCommand(self), PowerSpectrumCommand(self), + ClearStackCommand(self)] # Define commands @@ -242,8 +293,8 @@ class InfoCommand (CurveCommand): Argument(name='all', type='bool', default=False, count=1, help='Get all curve information.'), ] - self.fields = ['name', 'path', 'experiment', 'driver', 'filetype', 'note', - 'blocks', 'block sizes'] + self.fields = ['name', 'path', 'driver', 'note', 'command stack', + 'blocks', 'block names', 'block sizes'] for field in self.fields: args.append(Argument( name=field, type='bool', default=False, count=1, @@ -257,7 +308,7 @@ class InfoCommand (CurveCommand): fields = {} for key in self.fields: fields[key] = params[key] - if reduce(lambda x,y: x and y, fields.values()) == False: + if reduce(lambda x,y: x or y, fields.values()) == False: params['all'] = True # No specific fields set, default to 'all' if params['all'] == True: for key in self.fields: @@ -275,25 +326,79 @@ class InfoCommand (CurveCommand): def _get_path(self, curve): return curve.path - def _get_experiment(self, curve): - return curve.info.get('experiment', None) - def _get_driver(self, curve): return curve.driver - def _get_filetype(self, curve): - return curve.info.get('filetype', None) - def _get_note(self, curve): return curve.info.get('note', None) + def _get_command_stack(self, curve): + return curve.command_stack + def _get_blocks(self, curve): return len(curve.data) + def _get_block_names(self, curve): + return [block.info['name'] for block in curve.data] + def _get_block_sizes(self, curve): return [block.shape for block in curve.data] +class BlockInfoCommand (BlockCommand): + """Get selected information about a :class:`hooke.curve.Curve` data block. + """ + def __init__(self, plugin): + super(BlockInfoCommand, self).__init__( + name='block info', arguments=[ + Argument( + name='key', count=-1, optional=False, + help='Dot-separted (.) key selection regexp.'), + Argument( + name='output', + help=""" +File name for the output (appended). +""".strip()), + ], + help=self.__doc__, plugin=plugin) + + def _run(self, hooke, inqueue, outqueue, params): + block = self._block(hooke, params) + values = {'index': self._block_index(hooke, params)} + for key in params['key']: + keys = [(0, key.split('.'), block.info)] + while len(keys) > 0: + index,key_stack,info = keys.pop(0) + regexp = re.compile(key_stack[index]) + matched = False + for k,v in info.items(): + if regexp.match(k): + matched = True + new_stack = copy.copy(key_stack) + new_stack[index] = k + if index+1 == len(key_stack): + vals = values + for k in new_stack[:-1]: + if k not in vals: + vals[k] = {} + vals = vals[k] + vals[new_stack[-1]] = v + else: + keys.append((index+1, new_stack, v)) + if matched == False: + raise ValueError( + 'no match found for %s (%s) in %s' + % (key_stack[index], key, sorted(info.keys()))) + if params['output'] != None: + curve = self._curve(hooke, params) + with open(params['output'], 'a') as f: + yaml.dump({curve.name:{ + 'path': curve.path, + block.info['name']: values + }}, f) + outqueue.put(values) + + class DeltaCommand (BlockCommand): """Get distance information between two points. @@ -355,7 +460,7 @@ True if you want the column-naming header line. def _run(self, hooke, inqueue, outqueue, params): data = self._block(hooke, params) - with open(params['output'], 'w') as f: + with open(os.path.expanduser(params['output']), 'w') as f: if params['header'] == True: f.write('# %s \n' % ('\t'.join(data.info['columns']))) numpy.savetxt(f, data, delimiter='\t') @@ -399,7 +504,8 @@ Name of the new column for storing the difference (without units, defaults to help=self.__doc__, plugin=plugin) def _run(self, hooke, inqueue, outqueue, params): - params = self.__setup_params(hooke=hooke, params=params) + self._add_to_command_stack(params) + params = self._setup_params(hooke=hooke, params=params) data_A = self._get_column(hooke=hooke, params=params, block_name='block A', column_name='column A') @@ -412,7 +518,7 @@ Name of the new column for storing the difference (without units, defaults to column_name='output column', values=out) - def __setup_params(self, hooke, params): + def _setup_params(self, hooke, params): curve = self._curve(hooke, params) if params['block A'] == None: params['block A'] = curve.data[0].info['name'] @@ -473,7 +579,8 @@ central differencing. help=self.__doc__, plugin=plugin) def _run(self, hooke, inqueue, outqueue, params): - params = self.__setup_params(hooke=hooke, params=params) + self._add_to_command_stack(params) + params = self._setup_params(hooke=hooke, params=params) x_data = self._get_column(hooke=hooke, params=params, column_name='x column') f_data = self._get_column(hooke=hooke, params=params, @@ -484,7 +591,7 @@ central differencing. column_name='output column', values=d) - def __setup_params(self, hooke, params): + def _setup_params(self, hooke, params): curve = self._curve(hooke, params) x_name,x_unit = split_data_label(params['x column']) f_name,f_unit = split_data_label(params['f column']) @@ -537,7 +644,8 @@ Otherwise, the chunks are end-to-end, and not overlapping. help=self.__doc__, plugin=plugin) def _run(self, hooke, inqueue, outqueue, params): - params = self.__setup_params(hooke=hooke, params=params) + self._add_to_command_stack(params) + params = self._setup_params(hooke=hooke, params=params) data = self._get_column(hooke=hooke, params=params) bounds = params['bounds'] if bounds != None: @@ -561,7 +669,7 @@ Otherwise, the chunks are end-to-end, and not overlapping. values=power) outqueue.put(b) - def __setup_params(self, hooke, params): + def _setup_params(self, hooke, params): if params['output block'] in self._block_names(hooke, params): raise Failure('output block %s already exists in %s.' % (params['output block'], @@ -578,6 +686,24 @@ Otherwise, the chunks are end-to-end, and not overlapping. return params +class ClearStackCommand (CurveCommand): + """Empty a curve's command stack. + """ + def __init__(self, plugin): + super(ClearStackCommand, self).__init__( + name='clear curve command stack', + help=self.__doc__, plugin=plugin) + i,arg = [(i,arg) for i,arg in enumerate(self.arguments) + if arg.name == 'curve'][0] + arg = copy.copy(arg) + arg.callback = unloaded_current_curve_callback + self.arguments[i] = arg + + def _run(self, hooke, inqueue, outqueue, params): + curve = self._curve(hooke, params) + curve.command_stack = CommandStack() + + class OldCruft (object): def do_forcebase(self,args):