Updates the signal plots kwarg *'plot'*, which is
        either 'response' or (well actually anything).

        For other arguments, see: :meth:`FFTWidget.updateData<sparkle.gui.plotting.pyqtgraph_widgets.FFTWidget.updateData>`
190955
def updateSignal(self, *args, **kwargs):
        
        p = kwargs.pop('plot')
        if p == 'response':
            self.responseSignalPlot.updateData(*args, **kwargs)
        else:
            self.stimSignalPlot.updateData(*args, **kwargs)
1232194
def update(self, *args, **kwargs):
        
        super(DictProxy, self).update(*args, **kwargs)
        return self
1359878
def run(self):
        
        self.log_data.clear()
        self._plot_refresh = True  # flag that requests that plot axes are refreshed when self.plot is called next time
        self.is_running = True
        self.start_time = datetime.datetime.now()


        self._current_subscript_stage = {
            'current_subscript': None,
            'subscript_exec_count':{},
            'subscript_exec_duration':{}
        }

        # update the datapath of the subscripts, connect their progress signal to the receive slot
        for subscript in list(self.scripts.values()):
            subscript.data_path = os.path.join(self.filename(create_if_not_existing=False), self.SUBSCRIPT_DATA_DIR)
            subscript.updateProgress.connect(self._receive_signal)
            subscript.started.connect(lambda: self._set_current_subscript(True))
            subscript.finished.connect(lambda: self._set_current_subscript(False))
            self._current_subscript_stage['subscript_exec_count'].update({subscript.name:0})
            self._current_subscript_stage['subscript_exec_duration'].update({subscript.name: datetime.timedelta(0)})

                #todo: 170202JG (search for this to find related todos) need to test this:
                # do we need to connect the log functions of the subscript to the mother script?, e.g
                # subscript.log.connect(self.log)


        self.log('starting script {:s} at {:s} on {:s}'.format(self.name, self.start_time.strftime('%H:%M:%S'),self.start_time.strftime('%d/%m/%y')))
        self._abort = False

        #saves standard to disk
        if self.settings['save']:
            self.save_b26()

        self.started.emit()

        self._function()
        self.end_time  = datetime.datetime.now()
        self.log('script {:s} finished at {:s} on {:s}'.format(self.name, self.end_time.strftime('%H:%M:%S'),self.end_time.strftime('%d/%m/%y')))

        #saves standard to disk
        if self.settings['save']:
            self.save_data()
            self.save_log()
            self.save_image_to_disk()

        success = not self._abort

        # disconnect subscripts
        for subscript in list(self.scripts.values()):
            subscript.started.disconnect()
            subscript.updateProgress.disconnect()
            subscript.finished.disconnect()
        self.is_running = False
        self.finished.emit()
1180533
def update(self, sid, **kwargs):
        
        item = self[sid]
        for attribute, value in kwargs.items():
            item[attribute] = value
        self[sid] = item
1271378
def update(self, **kwargs):
        
        data = self._generate_input_dict(**kwargs)
        self.load(self.client.put('/'.join(self.url.split('/')[:-1]) + 's', data=data))
        return self
813936
def plotit(self):
        '''
        
        '''
        [self._plot(i) for i in range(len(self.plots))]
1175635
def update_stats(self, stats, delta, sample_rate=1):
        
        if not isinstance(stats, list):
            stats = [stats]

        data = dict((stat, "%s|c" % delta) for stat in stats)
        self.send(data, sample_rate)
1068846
def _plotxw(self,*args,**kwargs): #pragma: no cover
        
        xw= self.xw()
        #BOVY: CHECK THAT THIS IS CORRECT
        plot.bovy_plot(2.*m.pi*nu.fft.fftfreq(len(self.t),
                                              d=(self.t[1]-self.t[0]))\
                           [0:len(xw)],
                       xw,*args,**kwargs)
789726
def update_frame(self, key, ranges=None, element=None):
        
        self.generate_plot(key, ranges, element)
129391
def update_channels(self):
        """"""
        group_dict = {k['name']: i for i, k in enumerate(self.groups)}
        group_index = group_dict[self.idx_group.currentText()]
        self.one_grp = self.groups[group_index]

        self.idx_chan.clear()

        self.idx_chan.setSelectionMode(QAbstractItemView.ExtendedSelection)
        for chan in self.one_grp['chan_to_plot']:
            name = chan + '—(' + '+'.join(self.one_grp['ref_chan']) + ')'
            item = QListWidgetItem(name)
            self.idx_chan.addItem(item)
391708
async def update_data_status(self, **kwargs):
        
        await self._send_manager_command(ExecutorProtocol.UPDATE, extra_fields={
            ExecutorProtocol.UPDATE_CHANGESET: kwargs
        })
80562
def update(self, callback=None, errback=None, **kwargs):
        
        if not self.data:
            raise MonitorException('monitor not loaded')

        def success(result, *args):
            self.data = result
            if callback:
                return callback(self)
            else:
                return self

        return self._rest.update(self.data['id'], {}, callback=success, errback=errback, **kwargs)
877870
def animate_graph(self, loop, user_data=None):
        
        self.view.update_displayed_information()

        # Save to CSV if configured
        if self.save_csv or self.csv_file is not None:
            output_to_csv(self.view.summaries, self.csv_file)

        # Set next update
        self.animate_alarm = loop.set_alarm_in(
            float(self.refresh_rate), self.animate_graph)

        if self.args.debug_run:
            # refresh rate is a string in float format
            self.debug_run_counter += int(float(self.refresh_rate))
            if self.debug_run_counter >= 8:
                self.exit_program()
537326
def update_columns_dict(self, kwargs):
        
        super(Mesh, self).update_columns_dict(kwargs)

        # if kwargs.get('vnormals', None) is not None or kwargs.get('tnormals', None) is not None:
            # self._compute_mus()
        if kwargs.get('triangles', None) is not None:
            # reset visibilities and velocities so that they are reset
            # when next queried
            self.update_columns(visibilities=None, velocities=None)
237698
def _update_plot(self, key, element, bars, lims, ranges):
        
        main = self.adjoined.main
        _, y1 = element.range(1)
        offset = self.offset * y1
        range_item, main_range, dim = get_sideplot_ranges(self, element, main, ranges)

        # Check if plot is colormapped
        plot_type = Store.registry['matplotlib'].get(type(range_item))
        if isinstance(plot_type, PlotSelector):
            plot_type = plot_type.get_plot_class(range_item)
        opts = self.lookup_options(range_item, 'plot')
        if plot_type and issubclass(plot_type, ColorbarPlot):
            cidx = opts.options.get('color_index', None)
            if cidx is None:
                opts = self.lookup_options(range_item, 'style')
                cidx = opts.kwargs.get('color', None)
                if cidx not in range_item:
                    cidx = None
            cdim = None if cidx is None else range_item.get_dimension(cidx)
        else:
            cdim = None

        # Get colormapping options
        if isinstance(range_item, (HeatMap, Raster)) or cdim:
            style = self.lookup_options(range_item, 'style')[self.cyclic_index]
            cmap = cm.get_cmap(style.get('cmap'))
            main_range = style.get('clims', main_range)
        else:
            cmap = None

        if offset and ('offset_line' not in self.handles):
            self.handles['offset_line'] = self.offset_linefn(offset,
                                                             linewidth=1.0,
                                                             color='k')
        elif offset:
            self._update_separator(offset)

        if cmap is not None:
            self._colorize_bars(cmap, bars, element, main_range, dim)
        return bars
482197
public void updateDataSerieOnScatterPlot(String scatterID, int index, double[][] dataSerie){
        if (this.scatterPlots.containsKey(scatterID)){
            if (this.scatterPlotsData.containsKey(scatterID)) {
                double[][] current = this.scatterPlotsData.get(scatterID);
                this.scatterPlotsData.put(scatterID, concatenateArrays(current, dataSerie));
            } else{
                // Create the data.
                addDataSerieToScatterPlot(scatterID, dataSerie);
                return;
            }
            this.scatterPlots.get(scatterID).updateSeries(index, this.scatterPlotsData.get(scatterID));
//            this.scatterPlots.get(scatterID).addSeries(this.scatterPlotsData.get(scatterID), scatterID, null);
        }
    }
323803
def update_plot(self, indep_var, dep_var):
        
        evaluated_model = self.ig._eval_model()
        plot = self.ig._plots[(indep_var, dep_var)]
        y_vals = getattr(evaluated_model, dep_var.name)
        x_vals = self.ig._x_points[indep_var]
        plot.set_data(x_vals, y_vals)