def _update_speed(self): current_time = time.time() self.__elapsed = current_time - self.__starttime # we have the diff size pos_diff = self.__transfersize - self.__startingposition self.__datatransfer = pos_diff / self.__elapsed if self.__datatransfer < 0: self.__datatransfer = 0 try: round_fsize = int(round(self.__filesize*1024, 0)) round_rsize = int(round(self.__transfersize, 0)) self.__time_remaining_secs = int(round((round_fsize - \ round_rsize)/self.__datatransfer, 0)) self.__time_remaining = \ convert_seconds_to_fancy_output(self.__time_remaining_secs) except (ValueError, TypeError,): self.__time_remaining = "(%s)" % (_("infinite"),)
def _compute_progress_stats(self): """ Compute the progress statistics by reading individual ones. """ downloaded_size = 0 total_size = 0 time_remaining = 0 with self._progress_data_lock: all_started = len(self._progress_data) == len(self._url_path_list) for th_id, data in self._progress_data.items(): downloaded_size += data.get('downloaded_size', 0) total_size += data.get('total_size', 0) # data_transfer from Python threading bullshit is not reliable # with multiple threads and causes inaccurate informations to be # printed # data_transfer += data.get('data_transfer', 0) tr = data.get('time_remaining_secs', 0) if tr > 0: time_remaining += tr elapsed_t = time.time() - self.__startup_time if elapsed_t < 0.1: elapsed_t = 0.1 data_transfer = int(downloaded_size / elapsed_t) average = 0 # total_size is in kbytes # downloaded_size is in bytes if total_size > 0 and all_started: average = int(float(downloaded_size / 1000) / total_size * 100) time_remaining_str = convert_seconds_to_fancy_output(time_remaining) if not all_started: time_remaining_str = "~%s" % (time_remaining_str,) return { "downloaded_size": downloaded_size, "total_size": total_size, "time_remaining": time_remaining, "time_remaining_str": time_remaining_str, "all_started": all_started, "data_transfer": data_transfer, "average": average, }
def _update_speed(self): current_time = time.time() self.__elapsed = current_time - self.__starttime # we have the diff size pos_diff = self.__transfersize - self.__startingposition self.__datatransfer = pos_diff / self.__elapsed if self.__datatransfer < 0: self.__datatransfer = 0 try: round_fsize = int(round(self.__filesize * 1000, 0)) round_rsize = int(round(self.__transfersize, 0)) self.__time_remaining_secs = int(round((round_fsize - \ round_rsize)/self.__datatransfer, 0)) self.__time_remaining = \ convert_seconds_to_fancy_output(self.__time_remaining_secs) except ( ValueError, TypeError, ): self.__time_remaining = "(%s)" % (_("infinite"), )
def _update_speed(self): cur_time = time.time() self.__elapsed = cur_time - self.__starttime last_elapsed = cur_time - self.__last_update_time # we have the diff size x_delta = self.__downloadedsize - self.__startingposition x_delta_now = self.__downloadedsize - self.__last_downloadedsize el_factor = self.__elapsed if self.__elapsed > 1: el_factor = 1 if (last_elapsed > 0) and (self.__elapsed > 0): self.__datatransfer = 0.5 * self.__datatransfer + \ 0.5 * (el_factor * x_delta / self.__elapsed + \ (1-el_factor) * x_delta_now / last_elapsed) else: self.__datatransfer = 0.0 self.__last_update_time = cur_time self.__last_downloadedsize = self.__downloadedsize if self.__datatransfer < 0: self.__datatransfer = 0.0 rounded_remote = int(round(self.__remotesize * 1000, 0)) rounded_downloaded = int(round(self.__downloadedsize, 0)) x_delta = rounded_remote - rounded_downloaded if self.__datatransfer > 0: tx_round = round(x_delta/self.__datatransfer, 0) self.__time_remaining_secs = int(tx_round) if self.__time_remaining_secs < 0: self.__time_remaining = "(%s)" % (_("infinite"),) else: self.__time_remaining = \ convert_seconds_to_fancy_output(self.__time_remaining_secs)
def _push_progress_to_output(self, force = False): downloaded_size = 0 total_size = 0 time_remaining = 0 update_step = 0 pd = self.__progress_data.copy() pdlen = len(pd) # calculation for th_id in sorted(pd): data = pd.get(th_id) downloaded_size += data.get('downloaded_size', 0) total_size += data.get('total_size', 0) # data_transfer from Python threading bullshit is not reliable # with multiple threads and causes inaccurate informations to be # printed # data_transfer += data.get('data_transfer', 0) tr = data.get('time_remaining_secs', 0) if tr > 0: time_remaining += tr update_step += data.get('update_step', 0) elapsed_t = time.time() - self.__startup_time if elapsed_t < 0.1: elapsed_t = 0.1 data_transfer = downloaded_size / elapsed_t self.__data_transfer = data_transfer average = 100 # total_size is in kbytes # downloaded_size is in bytes if total_size > 0: average = int(float(downloaded_size/1024)/total_size * 100) self.__average = average if pdlen > 0: update_step = update_step/pdlen else: update_step = 0 time_remaining = convert_seconds_to_fancy_output(time_remaining) self.__time_remaining_sec = time_remaining update_time_delta = 0.5 cur_t = time.time() if ((cur_t > (self.__progress_update_t + update_time_delta)) \ or force or (self.__first_refreshes > 0)) and self.__show_progress: self.__first_refreshes -= 1 self.__progress_update_t = cur_t eta_txt = _("ETA") sec_txt = _("sec") # as in XX kb/sec down_size_txt = str(round(float(downloaded_size)/1024, 1)) total_size_txt = str(round(total_size, 1)) current_txt = darkgreen(down_size_txt) + "/" + red(total_size_txt) current_txt += " kB" # create progress bar barsize = 10 bartext = "[" curbarsize = 1 averagesize = (average*barsize)/100 while averagesize > 0: curbarsize += 1 bartext += "=" averagesize -= 1 bartext += ">" diffbarsize = barsize-curbarsize while diffbarsize > 0: bartext += " " diffbarsize -= 1 if self.__show_speed: bartext += "] => %s" % (bytes_into_human(data_transfer),) bartext += "/%s : %s: %s" % (sec_txt, eta_txt, time_remaining,) else: bartext += "]" myavg = str(average) if len(myavg) < 2: myavg = " "+myavg current_txt += " <-> "+myavg+"% "+bartext+" " TextInterface.output(self, current_txt, back = True) self.__old_average = average