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
