Increment total pbar value.
336864
def update_total(self, n=1):
    """"""
    with self._lock:
      self._pbar.total += n
      self.refresh()
856135
def __up_cmp(self, obj1, obj2):
        """"""
        if obj1.update_order > obj2.update_order:
            return 1
        elif obj1.update_order < obj2.update_order:
            return -1
        else:
            return 0
150920
def add(self, value):
        """"""
        self._data.append(value)
        if len(self._data) > self._max_count:
            self._data.popleft()
        return sum(self._data)/len(self._data)
1297556
def increment(version):
        """"""
        release_version = os.environ.get("RELEASE_VERSION", None)
        if release_version is not None:
            return release_version
        if isinstance(version, LegacyVersion):
            msg = """{0} is considered a legacy version and does not
            support automatic incrementing.  Please bring your version
            numbering into PEP440 standards and then it can be
            automatically incremented.
            """
            raise Exception(msg.format(version))
        release_type = os.environ.get("RELEASE_TYPE", "micro")
        v = version._version
        # epoch
        epoch_name, epoch = VersionUtils.get_version_number(v, 0, None, "!")
        pre_name, pre = VersionUtils.get_version_number(v, 3, None, "pre")
        post_name, post = VersionUtils.get_version_number(v, 4, None, "post")
        dev_name, dev = VersionUtils.get_version_number(v, 2, None, "dev")
        _, major = VersionUtils.get_version_number(v[1], 0, 0)
        _, minor = VersionUtils.get_version_number(v[1], 1, None)
        _, micro = VersionUtils.get_version_number(v[1], 2, None)

        # Handle dev/pre/post
        if release_type == "pre":
            micro, post, pre = VersionUtils.process_pre(micro, post, pre)

        if release_type == "post":
            dev, post = VersionUtils.process_post(dev, post)

        if release_type == "dev":
            dev = VersionUtils.process_dev(dev)

        if release_type == "micro":
            dev, micro, minor, post, pre = VersionUtils.process_micro(
                dev, micro, minor, post, pre
            )

        if release_type == "minor":
            dev, micro, minor, post, pre = VersionUtils.process_minor(
                dev, micro, minor, post, pre
            )

        if release_type == "major":
            dev, major, micro, minor, post, pre = VersionUtils.process_major(
                dev, major, micro, minor, post, pre
            )

        # Handle Epoch
        if release_type == "epoch":
            dev, epoch, major, micro, minor, post, pre = VersionUtils.process_epoch(
                dev, epoch, major, micro, minor, post, pre
            )

        local = "".join(v[5] or []) or None

        version_list = [major, minor, micro]
        if release_type not in ["epoch", "major", "minor", "micro", "pre"]:
            version_list += list(v[1][3:])
        version_string = ".".join([str(x) for x in version_list if x or x == 0])

        if epoch:
            version_string = str(epoch) + epoch_name + version_string
        if pre is not None:
            version_string = VersionUtils.calc_pre_version_string(
                pre, pre_name, version_string
            )
        if post is not None:
            version_string += "." + post_name + str(post)
        if dev is not None:
            version_string += "." + dev_name + str(dev)
        if local is not None:
            version_string += "." + str(local)

        return version_string
1323136
def increment(self, n=1):
        
        with self.count.get_lock():
            self.count.value += n
1193828
def increment(self):
    """"""
    self.value += self.increment_size
    return self.value - self.increment_size
1253226
def update(self, n=1):
    """"""
    with self._lock:
      self._pbar.update(n)
      self.refresh()
918057
def incrementSub(self, amount=1):
        
        self._subProgressBar.setValue(self.subValue() + amount)
        QApplication.instance().processEvents()
638752
def _increment(self, n=1):
        """"""
        if self._cur_position >= self.num_tokens-1:
            self._cur_positon = self.num_tokens - 1
            self._finished = True
        else:
            self._cur_position += n
639577
def Increment(self, delta, fields=None):
    """"""
    if delta < 0:
      raise ValueError(
          "Counter increment should not be < 0 (received: %d)" % delta)

    self._metric_values[_FieldsToKey(fields)] = self.Get(fields=fields) + delta
434067
def increment_bucket_count(self, value):
        """"""
        if len(self._bounds) == 0:
            self._counts_per_bucket[0] += 1
            return 0

        for ii, bb in enumerate(self._bounds):
            if value < bb:
                self._counts_per_bucket[ii] += 1
                return ii
        else:
            last_bucket_index = len(self._bounds)
            self._counts_per_bucket[last_bucket_index] += 1
            return last_bucket_index
714446
def Record(self, value):
    """"""
    self.sum += value
    self.count += 1

    pos = bisect.bisect(self.bins, value) - 1
    if pos < 0:
      pos = 0
    elif pos == len(self.bins):
      pos = len(self.bins) - 1

    self.heights[pos] += 1
886231
def increment(self, name, value):
        
        for counter in self._counters:
            counter.increment(name, value)
1299088
def increment_display_ref_count(self, amount: int=1):
        """"""
        display_ref_count = self.__display_ref_count
        self.__display_ref_count += amount
        for display_data_channel in self.display_data_channels:
            display_data_channel.increment_display_ref_count(amount)
35974
def increment(self, gold_set, test_set):
        ""
        self.gold += len(gold_set)
        self.test += len(test_set)
        self.correct += len(gold_set & test_set)
579823
def increment(self, size: int):
        '''
        '''
        assert size >= 0, size

        self.files += 1
        self.size += size
        self.bandwidth_meter.feed(size)
713460
def increment(self, delta=1, text=None):
        """"""
        return self.update(value=min(self.max, self.value + delta), text=text)