Update iteration's num_suggestions.
765049
def update_iteration_num_suggestions(self, num_suggestions):
        """"""
        iteration_config = self.experiment_group.iteration_config

        iteration_config.num_suggestions = num_suggestions
        self._update_config(iteration_config)
1149340
def increment(cls, v):
        """"""
        if not isinstance(v, ObjectNumber):
            v = ObjectNumber.parse(v)

        return v.rev(v.revision+1)
713460
def increment(self, delta=1, text=None):
        """"""
        return self.update(value=min(self.max, self.value + delta), text=text)
380771
def update(self, bandit, payout):
        '''
        
        '''

        self.choices.append(bandit)
        self.pulls[bandit] += 1
        self.wins[bandit] += payout
        self.bandits.payouts[bandit] += payout
673829
def update_iteration(self):
        """"""
        iteration_config = self.get_iteration_config()
        if not iteration_config:
            return
        experiments_metrics = self.experiment_group.get_experiments_metrics(
            experiment_ids=iteration_config.experiment_ids,
            metric=self.get_metric_name()
        )
        iteration_config.experiments_metrics = [m for m in experiments_metrics if m[1] is not None]
        self._update_config(iteration_config)
608861
def update(self, byts):
        '''
        
        '''
        self.size += len(byts)
        [h[1].update(byts) for h in self.hashes]
1156843
def update(self, score_vals):
        ''''''
        add = self.add
        for score, value in score_vals:
            add(score, value)
1150465
def refresh_meta(self):
        """"""

        # these calcs are duplicated in __init__()
        setattr(self, '_num_classes', len(self.index))
        setattr(self, '_colnums', np.arange(0, self._num_classes))
        try:
            setattr(self, '_neg_label',
                    next(label for label in self.columns if str(label).strip().lower()[0] in ('-nh0')))
        except StopIteration:
            setattr(self, '_neg_label', self.columns[-1])
        try:
            setattr(self, '_pos_label', next(label for label in self.columns if label != self._neg_label))
        except StopIteration:
            setattr(self, '_pos_label', infer_pos_label(self._neg_label))

        # TODO: reorder columns with newly guessed pos and neg class labels first

        # TODO: gather up additional meta calculations here so
        #       a Confusion matrix can be build from an existing DataFrame that contains confusion counts
        #       rather than just two columns of labels.
        self.__setattr__('_hist_labels', self.sum().astype(int))
        self.__setattr__('_num_total', self._hist_labels.sum())
        assert(self._num_total == self.sum().sum())
        setattr(self, '_num_pos_labels', self._hist_labels.get(self._pos_label, 0))
        # everything that isn't positive is negative
        setattr(self, '_num_neg_labels', self._num_total - self._num_pos_labels)
        setattr(self, '_hist_classes', self.T.sum())
        setattr(self, '_num_pos', self._hist_classes.get(self._pos_label, 0))
        setattr(self, '_num_neg', self._hist_classes.sum() - self._num_pos)  # everything that isn't positive is negative
        setattr(self, '_tp', self.get(self._pos_label, pd.Series()).get(self._pos_label, 0))
        setattr(self, '_tpr', safe_div(float(self._tp), self._num_pos))
        setattr(self, '_tn', np.diag(self).sum() - self._tp)
        setattr(self, '_tnr', safe_div(float(self._tn), self._num_neg))
        setattr(self, '_fp', self.get(self._pos_label, pd.Series()).sum() - self._tp)
        setattr(self, '_fpr', safe_div(float(self._fp), self._num_neg))
        setattr(self, '_fn', self._num_neg_labels - self._tn)
        setattr(self, '_fnr', safe_div(float(self._fn), self._num_pos))
        setattr(self, '_plr', safe_div(float(self._tpr), self._fpr))
        setattr(self, '_nlr', safe_div(float(self._fnr), self._tnr))
        setattr(self, '_binary_accuracy', safe_div(self._tp + self._tn, self._num_samples))
        setattr(self, '_binary_sensitivity', safe_div(self._tp, self._tp + self._fn))
        setattr(self, '_binary_specificity', safe_div(self._tn, self._tn + self._fp))
444403
def update(self, *args, **kwargs):
        """"""
        self._write_op(self._update_nosync, *args, **kwargs)
683931
def _update_items(self, items):
        
        self.items = items
        self.map = {item: idx for (idx, item) in enumerate(items)}
98828
def update(self, *args):
        
        for d in args:
            for (key, value) in d.items():
                self.__setitem__(key, value)
1001245
def update(self, values):
        ''''''
        d = self.value_pickler.dumps
        return self.cache.update(tuple((d(v) for v in values)))
1006310
def update(self):
        """"""
        # Init new stats
        stats = self.get_init_value()

        if self.input_method == 'local':
            # Update stats using the standard system lib
            # Note: Update is done in the processcount plugin
            # Just return the processes list
            stats = glances_processes.getlist()

        elif self.input_method == 'snmp':
            # No SNMP grab for processes
            pass

        # Update the stats
        self.stats = stats

        # Get the max values (dict)
        # Use Deep copy to avoid change between update and display
        self.max_values = copy.deepcopy(glances_processes.max_values())

        return self.stats
488325
def update(self, instance, oldValue, newValue):
    """"""
    self.__set__(instance,
                 self.__get__(instance, None) + newValue - (oldValue or 0))
1077225
def update(self, data):
        
        for key, value in data.items():
            setattr(self, key, value)
1349321
def update(self, sequence=None, **mapping):
        """"""
        if sequence is not None:
            if isinstance(sequence, dict):
                for slot in sequence:
                    self[slot] = sequence[slot]
            else:
                for slot, value in sequence:
                    self[slot] = value
        if mapping:
            for slot in sequence:
                self[slot] = sequence[slot]
486581
def p_kw_args_update(self, p):
        """"""
        p[0] = p[1]
        for key in p[3]:
            if key in p[1]:
                msg = "Keyword argument '%s' defined more than once." % key
                self.errors.append((msg, p.lineno(2), self.path))
        p[0].update(p[3])