def progressbar_count_widgets(pbar: ProgressBar): from progressbar import widgets if pbar.max_value: return [ widgets.Percentage(**pbar.widget_kwargs), ' ', widgets.SimpleProgress(format="({value:,} of {max_value:,})", new_style=True, **pbar.widget_kwargs), ' ', widgets.Bar(**pbar.widget_kwargs), ' ', widgets.Timer(**pbar.widget_kwargs), ] else: return [ widgets.AnimatedMarker(**pbar.widget_kwargs), ' ', widgets.BouncingBar(**pbar.widget_kwargs), ' ', widgets.Counter(**pbar.widget_kwargs), ' ', widgets.Timer(**pbar.widget_kwargs), ]
async def show_progresses_offline(self): from progressbar import ProgressBar, widgets barformat_notfinalized = [ widgets.AnimatedMarker(), ' ', widgets.Counter(), ' ', widgets.BouncingBar(), ' ', widgets.Timer()] class LooseAdaptiveETA(widgets.AdaptiveETA): # Stabilize the ETA on results from large batches rushes in NUM_SAMPLES = 100 barformat_finalized = [ widgets.AnimatedMarker(), ' ', widgets.Percentage(), ' of ', widgets.FormatLabel('%(max)d'), ' ', widgets.Bar(), ' ', widgets.Timer('Elapsed: %s'), ' ', LooseAdaptiveETA()] self.pbar = ProgressBar(widgets=barformat_notfinalized) self.pbar.start() notfinalized = True while self.running: if notfinalized and self.scan_finished: notfinalized = False self.pbar = ProgressBar(maxval=self.reads_found, widgets=barformat_finalized) self.pbar.currval = self.reads_processed self.pbar.start() else: self.pbar.maxval = self.reads_found self.pbar.update(self.reads_processed) try: await asyncio.sleep(0.3) except CancelledError: break
def get_pbar(max_value): pbar = progressbar.ProgressBar(widgets=[ widgets.Percentage(), ' (', widgets.SimpleProgress(), ')', ' ', widgets.Bar(), ' ', widgets.Timer(), ' ', widgets.AdaptiveETA(), ' ', widgets.DynamicMessage('Accuracy') ], max_value=max_value) return pbar
def DisplayProgressBar(self, ProcessingResults, ExpectedResultsSize, CheckInterval=1, type="minute"): ''' Display a progress bar for multiprocessing. This function should be used after pool.close(No need to use pool.join anymore). The call back function for pool.async should be set as CallbackForProgressBar. :param multiprocessing.pool.AsyncResult ProcessingResults: Processing results returned by pool.async. :param int ExpectedResultsSize: How many result you will reveive, i.e. the total length of progress bar. :param float CheckInterval: How many seconds will the progress bar be updated. When it's too large, the main program may hang there. :param String type: Three types: "minute", "hour", "second"; corresponds displaying iters/minute iters/hour and iters/second. ''' self.ProcessingResults = ProcessingResults ProgressBarWidgets = [ progressbar_widgets.Percentage(), ' ', progressbar_widgets.Bar(), ' ', progressbar_widgets.SimpleProgress(), ' ', progressbar_widgets.Timer(), ' ', progressbar_widgets.AdaptiveETA() ] self.ProgressBar = progressbar.ProgressBar(ExpectedResultsSize, ProgressBarWidgets) self.StartTime = time.time() PreviousNumberOfResults = 0 self.ProgressBar.start() while self.ProcessingResults.ready() == False: self.Update() time.sleep(CheckInterval) time.sleep(CheckInterval) self.Update() self.ProgressBar.finish() self.EndTime = time.time() print("Processing finished.") #print "Processing results: ", self.TotalResults print("Time Elapsed: %.2fs, or %.2fmins, or %.2fhours" % ((self.EndTime - self.StartTime), (self.EndTime - self.StartTime) / 60, (self.EndTime - self.StartTime) / 3600)) logger.info("Processing finished.") logger.info("Processing results: " + str(self.TotalResults)) logger.info("Time Elapsed: %.2fs, or %.2fmins, or %.2fhours" % ((self.EndTime - self.StartTime), (self.EndTime - self.StartTime) / 60, (self.EndTime - self.StartTime) / 3600)) return
def get_progressbar_widget_list(nepoch: int) -> BarWidgetsReturn: epoch_status_fmt_str: str = 'EPOCH: %(epoch_ix)d/%(nepoch)d' epoch_status = progressbar.FormatCustomText( epoch_status_fmt_str, dict(epoch_ix=0, nepoch=nepoch)) widgets_list: List[widgets.WidgetBase] = [ widgets.Percentage(), ' ', widgets.SimpleProgress(format='(%s)' % widgets.SimpleProgress.DEFAULT_FORMAT), ' ', epoch_status, ' ', widgets.Bar(), ' ', widgets.Timer(), ] return widgets_list, epoch_status
def __init__(self, prefix, max_value): ProgressBar.__init__(self, prefix=prefix, max_value=max_value, is_terminal=True, term_width=200) self.widgets = [ widgets.Percentage(**self.widget_kwargs), ' ', widgets.SimpleProgress(format='(%s)' % widgets.SimpleProgress.DEFAULT_FORMAT, **self.widget_kwargs), ' ', widgets.Bar(**self.widget_kwargs), ' ', widgets.Timer(**self.widget_kwargs), ' ', widgets.ETA(**self.widget_kwargs), ]
def start(self, time_max): """ Start the simulation's progress bar Args: time_max (:obj:`float`): the simulation's end time """ if self.use: self.bar = ProgressBar(widgets=[ widgets.Percentage(), ' ', widgets.SimpleProgress( format='%(value)d/%(max_value)d (time_max)'), ' ', widgets.Bar(), ' ', widgets.Timer(), ' ', widgets.AdaptiveETA(), ], max_value=time_max).start()
def _run(): """ This will retry up to MAX_ATTEMPTS. Will only retry on a psycopg2.Error. """ self.logger.info('STARTING %s;', self.object_type) progress_bar = \ ProgressBar( widgets=[ 'Object Type: %s;' % self.object_type, ' ', widgets.AnimatedMarker(), ' ', widgets.Counter(), ' ', widgets.Timer()], max_value=UnknownLength) progress_bar.update(0) for index, row in enumerate(self.get_rows()): progress_bar.update(index) self.extractor.update_handler(row) self.extractor.flush_table_data() sys.stderr.write('\n') self.logger.info('FINISHED %s;', self.object_type)
from .Fuzzer import FuzzManager from .Logger import Logger from .analyse.linecoverage import linecoverage # The widgets used by the process bar WIDGETS = [ widgets.Percentage(), ' (', widgets.SimpleProgress(), ')', ' ', widgets.Bar("="), ' ', widgets.Timer(), ' ', widgets.ETA(), ] class Macke: """ Main container for all steps of the MACKE analysis """ # static "constants" SYM_ONLY = 0 FUZZ_ONLY = 1 FLIPPER = 2