Reset the attempt counter
343865
def reset(self):
        """"""
        self._attempts = 0
        self._cur_delay = self.delay
        self._cur_stoptime = None
90057
def do_counter_reset(self, element, decl, pseudo):
        """"""
        step = self.state[self.state['current_step']]
        counter_name = ''
        for term in decl.value:
            if type(term) is ast.WhitespaceToken:
                continue

            elif type(term) is ast.IdentToken:
                if counter_name:
                    step['counters'][counter_name] = 0
                counter_name = term.value

            elif type(term) is ast.LiteralToken:
                if counter_name:
                    step['counters'][counter_name] = 0
                    counter_name = ''

            elif type(term) is ast.NumberToken:
                if counter_name:
                    step['counters'][counter_name] = int(term.value)
                    counter_name = ''

            else:
                log(WARN, u"Unrecognized counter-reset term {}"
                    .format(type(term)).encode('utf-8'))
        if counter_name:
            step['counters'][counter_name] = 0
1191984
def hard_reset(self):
        """"""
        if self.shuffle:
            self._shuffle_data()
        self.cursor = -self.batch_size
        self._cache_data = None
        self._cache_label = None
1003051
def reset(self, **kwargs):
    
    self.env.reset(**kwargs)
    if self.override_num_noops is not None:
      noops = self.override_num_noops
    else:
      noops = self.unwrapped.np_random.randint(1, self.noop_max + 1)  # pylint: disable=E1101
    assert noops > 0
    obs = None
    for _ in range(noops):
      obs, _, done, _ = self.env.step(self.noop_action)
      if done:
        obs = self.env.reset(**kwargs)
    return obs
939086
def reset(self):
        """"""
        if self.seq is not None and self.shuffle:
            random.shuffle(self.seq)
        if self.last_batch_handle != 'roll_over' or \
            self._cache_data is None:
            if self.imgrec is not None:
                self.imgrec.reset()
            self.cur = 0
            if self._allow_read is False:
                self._allow_read = True
1191445
def reset(self):
        '''
        '''
        for index in range(self.counts_len):
            self.counts[index] = 0
        self.total_count = 0
        self.min_value = sys.maxsize
        self.max_value = 0
        self.start_time_stamp_msec = sys.maxsize
        self.end_time_stamp_msec = 0
488872
def reset(self):
        """"""
        self.alive.value = False
        qsize = 0
        try:
            while True:
                self.queue.get(timeout=0.1)
                qsize += 1
        except QEmptyExcept:
            pass
        print("Queue size on reset: {}".format(qsize))
        for i, p in enumerate(self.proc):
            p.join()
        self.proc.clear()
428599
def reset(self, blocking=True):
    
    promise = self.call('reset')
    if blocking:
      return promise()
    else:
      return promise
46188
public void reset()
    {
        _dstack.reset();
        _current1.reset();
        _last1.reset();
        _eof = false;
        _s = 0;
        _p = null;
    }
705865
def copy_reset(self):
        """"""
        # Reset settings
        self._filters = []
        self._filter_or = False
        self._paginate = True
        self._paginate_count = 0
        self._result_count = None
        self._result_limit = 500
        self._result_start = 0
694656
protected void retryDelay(int attemptCount) {
        if (attemptCount > 0) {
            try {
                Thread.sleep(attemptCount * retryDelay);
            } catch (InterruptedException e) {
                LOG.debug("Failed to sleep: " + e, e);
            }
        }
    }
65511
def reset(self):
        """"""
        try:
            self._invalidate_cached_registers()
            self._link.reset()
        except DAPAccess.Error as exc:
            six.raise_from(self._convert_exception(exc), exc)
258326
public Map<String, Long> resetRetryCounter() {
        Map<String, Long> result = retryCounter.asMap();
        retryCounter.clear();
        return result;
    }
625145
public function resetCounter () : int
    {
        return $this->_counter = $this->getContainerSize() + ( ($this->isUsingHandler()) ? $this->_DataHandler->countEntitys() : 0 );
    }
360178
def reset_game(self):
        """"""
        self.ms_game.reset_game()
        self.update_grid()
        self.time = 0
        self.timer.start(1000)
138441
def reset
      err = Zlib.send @func_reset, pointer

      Zlib.handle_error err, message

      @flags = READY

      reset_input
    end
594195
def reset(self):
        '''
        
        '''
        self.resetRNG()
        sNow = np.zeros(self.pop_size)
        Shk  = self.RNG.rand(self.pop_size)
        sNow[Shk < self.p_init] = 1
        self.sNow = sNow