rewind to start of log
963738
def _rewind(self):
        ''''''
        DFReader._rewind(self)
        self.offset = 0
        self.remaining = self.data_len
310970
public function rewind()
    {
        if ($this->datespan instanceof Day) {
            $this->current = $this->datespan;
        } else {
            $this->current = new Day($this->datespan->start());
        }
    }
395888
public function rewind() : void
    {
        $r = false;
        $err = ($this->stream === null || $this->seekable === false);

        if ($err === false) {
            $r = rewind($this->stream);
        }

        if ($err === true || $r === false) {
            // @codeCoverageIgnoreStart
            throw new \RuntimeException("Could not rewind stream.");
            // @codeCoverageIgnoreEnd
        }
    }
195678
def start_recording(self):
        """"""
        self._recording = True
        self._stop_recording.clear()
        self._source.start()
48746
def on_episode_begin(self, episode, logs):
        
        assert episode not in self.metrics
        assert episode not in self.starts
        self.metrics[episode] = []
        self.starts[episode] = timeit.default_timer()
900771
def cmd_log(self, reopen=False, rotate=False):
        
        cmd = b''

        if reopen:
            cmd += b'l'

        if rotate:
            cmd += b'L'

        return self.send_command(cmd)
456095
public function rewind()
    {
        if (0 !== $this->key) {
            $this->key = 0;
            $this->batchKey = 0;
            $this->page = 0;
            $this->response = null;
            $this->fetchNextPage();
        }
    }
1365497
public function rewind()
    {
        try {
            $this->getCursor()->rewind();
        } catch (LogicException $e) {
            $this->fresh();
            $this->getCursor()->rewind();
        }

        $this->position = 0;
    }
111164
def log_start(self, start):
        """"""
        if not logger.isEnabledFor(logging.INFO): return

        try:
            req = self.request

            logger.info("REQUEST {} {}?{}".format(req.method, req.path, req.query))
            logger.info(datetime.datetime.strftime(datetime.datetime.utcnow(), "DATE %Y-%m-%dT%H:%M:%S.%f"))

            ip = req.ip
            if ip:
                logger.info("\tIP ADDRESS: {}".format(ip))

            if 'authorization' in req.headers:
                logger.info('AUTH {}'.format(req.headers['authorization']))

            ignore_hs = set([
                'accept-language',
                'accept-encoding',
                'connection',
                'authorization',
                'host',
                'x-forwarded-for'
            ])
            hs = ["Request Headers..."]
            for k, v in req.headers.items():
                if k not in ignore_hs:
                    hs.append("\t{}: {}".format(k, v))

            logger.info(os.linesep.join(hs))

        except Exception as e:
            logger.warn(e, exc_info=True)
689296
public function rewind()
    {
        $keys = array_keys($this->items);

        $this->currentKey = !empty($keys) ? reset($keys) : null;
    }
583882
def _start(self):
        """"""
        self._enable_logpersist()
        logcat_file_path = self._configs.output_file_path
        if not logcat_file_path:
            f_name = 'adblog,%s,%s.txt' % (self._ad.model,
                                           self._ad._normalized_serial)
            logcat_file_path = os.path.join(self._ad.log_path, f_name)
        utils.create_dir(os.path.dirname(logcat_file_path))
        cmd = '"%s" -s %s logcat -v threadtime %s >> "%s"' % (
            adb.ADB, self._ad.serial, self._configs.logcat_params,
            logcat_file_path)
        process = utils.start_standing_subprocess(cmd, shell=True)
        self._adb_logcat_process = process
        self.adb_logcat_file_path = logcat_file_path
869931
public function rewind() {
    $this->end = false;
    $this->nodeList = [];
    $this->processedOidList = [];
    $this->currentNode = $this->startNode;
  }
370518
def start_new_log(self):
        ''''''
        filename = self.new_log_filepath()

        self.block_cnt = 0
        self.logfile = open(filename, 'w+b')
        print("DFLogger: logging started (%s)" % (filename))
        self.prev_cnt = 0
        self.download = 0
        self.prev_download = 0
        self.last_idle_status_printed_time = time.time()
        self.last_status_time = time.time()
        self.missing_blocks = {}
        self.acking_blocks = {}
        self.blocks_to_ack_and_nack = []
        self.missing_found = 0
        self.abandoned = 0
175734
def log_entries_in_range(entries, start, end):
    ''''''
    start = _timestamp_from_string(start)
    end = _timestamp_from_string(end)
    for entry in entries:
        log_timestamp = entry.get('timestamp', 0)
        if log_timestamp >= start and log_timestamp <= end:
            yield entry
310348
def before_log(logger, log_level):
    """"""
    def log_it(retry_state):
        logger.log(log_level,
                   "Starting call to '%s', this is the %s time calling it.",
                   _utils.get_callback_name(retry_state.fn),
                   _utils.to_ordinal(retry_state.attempt_number))

    return log_it
305379
public void rewind() throws IOException {
    if (!rewindable) {
      throw LOG.unableToRewindReader();
    }

    wrappedReader.unread(buffer, 0, pos);
    pos = 0;
  }
496347
public function rewind()
	{
		$this->offset = 0;
		$this->startAt = 0;
		$this->current = 0;
		$this->max = 0;
		$this->total = null;
		$this->executed = false;
		$this->issues = array();
	}