class ExperimentStats(Loggable):
elapsed = Property(depends_on="_elapsed")
_elapsed = Float
run_elapsed = Property(depends_on="_run_elapsed")
_run_elapsed = Float
nruns = Int
nruns_finished = Int
etf = String
start_at = String
end_at = String
run_duration = String
current_run_duration = String
total_time = Property(depends_on="_total_time")
_total_time = Float
_timer = Any
delay_between_analyses = Float
delay_before_analyses = Float
# _start_time = None
_post = None
use_clock = Bool(False)
clock = Instance(PieClockModel, ())
duration_tracker = Instance(AutomatedRunDurationTracker, ())
_run_start = 0
# experiment_queue = Any
def calculate_duration(self, runs=None):
# if runs is None:
# runs = self.experiment_queue.cleaned_automated_runs
self.duration_tracker.load()
dur = self._calculate_duration(runs)
# add an empirical fudge factor
# ff = polyval(FUDGE_COEFFS, len(runs))
self._total_time = dur # + ff
return self._total_time
# def calculate_etf(self):
# runs = self.experiment_queue.cleaned_automated_runs
# dur = self._calculate_duration(runs)
# self._total_time = dur
# self.etf = self.format_duration(dur)
def format_duration(self, dur):
post = self._post
if not post:
post = datetime.now()
dt = post + timedelta(seconds=int(dur))
return dt.strftime("%I:%M:%S %p %a %m/%d")
def _calculate_duration(self, runs):
dur = 0
if runs:
script_ctx = dict()
warned = []
ni = len(runs)
run_dur = 0
for a in runs:
sh = a.script_hash
if sh in self.duration_tracker:
run_dur += self.duration_tracker[sh]
else:
run_dur += a.get_estimated_duration(script_ctx, warned, True)
# run_dur = sum([a.get_estimated_duration(script_ctx, warned, True) for a in runs])
btw = self.delay_between_analyses * (ni - 1)
dur = run_dur + btw + self.delay_before_analyses
self.debug("nruns={} before={}, run_dur={}, btw={}".format(ni, self.delay_before_analyses, run_dur, btw))
return dur
def _get_run_elapsed(self):
return str(timedelta(seconds=self._run_elapsed))
def _get_elapsed(self):
return str(timedelta(seconds=self._elapsed))
def _get_total_time(self):
dur = timedelta(seconds=round(self._total_time))
return str(dur)
# def traits_view(self):
# v = View(VGroup(Readonly('nruns', label='Total Runs'),
# Readonly('nruns_finished', label='Completed'),
# Readonly('total_time'),
# Readonly('start_at'),
# Readonly('end_at'),
# Readonly('run_duration'),
# Readonly('current_run_duration', ),
# Readonly('etf', label='Est. finish'),
# Readonly('elapsed'),
# Readonly('run_elapsed'),
# show_border=True))
# return v
def start_timer(self):
st = time.time()
self._post = datetime.now()
def update_time():
e = round(time.time() - st)
d = {"_elapsed": e}
if self._run_start:
re = round(time.time() - self._run_start)
d["_run_elapsed"] = re
self.trait_set(**d)
self._timer = Timer(1000, update_time)
self._timer.start()
def stop_timer(self):
self.debug("Stop timer. self._timer: {}".format(self._timer))
if self._timer:
tt = self._total_time
et = self._elapsed
dt = tt - et
self.info("Estimated total time= {:0.1f}, elapsed time= {:0.1f}, deviation= {:0.1f}".format(tt, et, dt))
self._timer.stop()
def reset(self):
# self._start_time = None
self._post = None
self.nruns_finished = 0
self._elapsed = 0
self._run_elapsed = 0
self._run_start = 0
def update_run_duration(self, run, t):
a = self.duration_tracker
a.update(run.spec.script_hash, t)
def start_run(self, run):
self._run_start = time.time()
self.setup_run_clock(run)
self.current_run_duration = self.get_run_duration(run.spec, as_str=True)
def get_run_duration(self, run, as_str=False):
sh = run.script_hash
if sh in self.duration_tracker:
self.debug("using duration tracker value")
rd = self.duration_tracker[sh]
else:
rd = run.get_estimated_duration(force=True)
rd = round(rd)
if as_str:
rd = str(timedelta(seconds=rd))
self.debug("run duration: {}".format(rd))
return rd
def finish_run(self):
self._run_start = 0
self.nruns_finished += 1
if self.clock:
self.clock.stop()
def continue_run(self):
if self.clock:
self.clock.finish_slice()
def setup_run_clock(self, run):
if self.use_clock:
ctx = run.spec.make_script_context()
extraction_slice = run.extraction_script.calculate_estimated_duration(ctx)
measurement_slice = run.measurement_script.calculate_estimated_duration(ctx)
def convert_hexcolor_to_int(c):
c = c[1:]
func = lambda i: int(c[i : i + 2], 16)
return map(func, (0, 2, 4))
ec, mc = map(convert_hexcolor_to_int, (EXTRACTION_COLOR, MEASUREMENT_COLOR))
self.clock.set_slices([extraction_slice, measurement_slice], [ec, mc])
self.clock.start()
class ExperimentStats(Loggable):
elapsed = Property(depends_on='_elapsed')
_elapsed = Float
run_elapsed = Property(depends_on='_run_elapsed')
_run_elapsed = Float
remaining = Property(depends_on='_elapsed, _total_time')
nruns = Int
nruns_finished = Int
etf = String
start_at = String
end_at = String
run_duration = String
current_run_duration = String
total_time = Property(depends_on='_total_time')
_total_time = Float
_timer = Any
delay_between_analyses = Float
delay_before_analyses = Float
# _start_time = None
_post = None
use_clock = Bool(False)
clock = Instance(PieClockModel, ())
duration_tracker = Instance(AutomatedRunDurationTracker, ())
_run_start = 0
# experiment_queue = Any
def calculate_duration(self, runs=None):
self.duration_tracker.load()
dur = self._calculate_duration(runs)
self._total_time = dur
return self._total_time
def format_duration(self, dur, post=None):
if post is None:
post = self._post
if not post:
post = datetime.now()
dt = post + timedelta(seconds=int(dur))
return dt.strftime('%H:%M:%S %a %m/%d')
def start_timer(self):
st = time.time()
self._post = datetime.now()
def update_time():
e = round(time.time() - st)
d = {'_elapsed': e}
if self._run_start:
re = round(time.time() - self._run_start)
d['_run_elapsed'] = re
self.trait_set(**d)
self._timer = Timer(1000, update_time)
self._timer.start()
def stop_timer(self):
self.debug('Stop timer. self._timer: {}'.format(self._timer))
if self._timer:
tt = self._total_time
et = self._elapsed
dt = tt - et
self.info(
'Estimated total time= {:0.1f}, elapsed time= {:0.1f}, deviation= {:0.1f}'
.format(tt, et, dt))
self._timer.stop()
def reset(self):
# self._start_time = None
self._post = None
self.nruns_finished = 0
self._elapsed = 0
self._run_elapsed = 0
self._run_start = 0
def update_run_duration(self, run, t):
a = self.duration_tracker
a.update(run, t)
def start_run(self, run):
self._run_start = time.time()
self.setup_run_clock(run)
self.current_run_duration = self.get_run_duration(run.spec,
as_str=True)
def get_run_duration(self, run, as_str=False):
sh = run.script_hash
if sh in self.duration_tracker:
self.debug('using duration tracker value')
rd = self.duration_tracker[sh]
else:
rd = run.get_estimated_duration(force=True)
rd = round(rd)
if as_str:
rd = str(timedelta(seconds=rd))
self.debug('run duration: {}'.format(rd))
return rd
def finish_run(self):
self._run_start = 0
self.nruns_finished += 1
self.debug('finish run. runs completed={}'.format(self.nruns_finished))
if self.clock:
self.clock.stop()
def continue_run(self):
if self.clock:
self.clock.finish_slice()
def setup_run_clock(self, run):
if self.use_clock:
ctx = run.spec.make_script_context()
extraction_slice = run.extraction_script.calculate_estimated_duration(
ctx)
measurement_slice = run.measurement_script.calculate_estimated_duration(
ctx)
def convert_hexcolor_to_int(c):
c = c[1:]
func = lambda i: int(c[i:i + 2], 16)
return map(func, (0, 2, 4))
ec, mc = map(convert_hexcolor_to_int,
(EXTRACTION_COLOR, MEASUREMENT_COLOR))
self.clock.set_slices([extraction_slice, measurement_slice],
[ec, mc])
self.clock.start()
# private
def _calculate_duration(self, runs):
dur = 0
if runs:
script_ctx = dict()
warned = []
ni = len(runs)
run_dur = 0
for a in runs:
sh = a.script_hash
if sh in self.duration_tracker:
t = a.make_truncated_script_hash()
if a.has_conditionals() and t in self.duration_tracker:
run_dur += self.duration_tracker.probability_model(
sh, t)
else:
run_dur += self.duration_tracker[sh]
else:
run_dur += a.get_estimated_duration(
script_ctx, warned, True)
btw = self.delay_between_analyses * (ni - 1)
dur = run_dur + btw + self.delay_before_analyses
self.debug('nruns={} before={}, run_dur={}, btw={}'.format(
ni, self.delay_before_analyses, run_dur, btw))
return dur
def _get_run_elapsed(self):
return str(timedelta(seconds=self._run_elapsed))
def _get_elapsed(self):
return str(timedelta(seconds=self._elapsed))
def _get_total_time(self):
dur = timedelta(seconds=round(self._total_time))
return str(dur)
def _get_remaining(self):
dur = timedelta(seconds=round(self._total_time - self._elapsed))
return str(dur)
class ExperimentStats(Loggable):
elapsed = Property(depends_on='_elapsed')
_elapsed = Float
run_elapsed = Property(depends_on='_run_elapsed')
_run_elapsed = Float
remaining = Property(depends_on='_elapsed, _total_time')
nruns = Int
nruns_finished = Int
etf = String
start_at = String
end_at = String
run_duration = String
current_run_duration = String
total_time = Property(depends_on='_total_time')
_total_time = Float
_timer = Any
delay_between_analyses = Float
delay_before_analyses = Float
delay_after_blank = Float
delay_after_air = Float
# _start_time = None
_post = None
use_clock = Bool(False)
clock = Instance(PieClockModel, ())
duration_tracker = Instance(AutomatedRunDurationTracker, ())
_run_start = 0
# experiment_queue = Any
def calculate_duration(self, runs=None):
self.duration_tracker.load()
dur = self._calculate_duration(runs)
self._total_time = dur
return self._total_time
def format_duration(self, dur, post=None, fmt='%H:%M:%S %a %m/%d'):
if post is None:
post = self._post
if not post:
post = datetime.now()
dt = post + timedelta(seconds=int(dur))
if fmt == 'iso':
return dt.isoformat()
else:
return dt.strftime(fmt)
def start_timer(self):
st = time.time()
self._post = datetime.now()
def update_time():
e = round(time.time() - st)
d = {'_elapsed': e}
if self._run_start:
re = round(time.time() - self._run_start)
d['_run_elapsed'] = re
self.trait_set(**d)
self._timer = Timer(1000, update_time)
self._timer.start()
def stop_timer(self):
self.debug('Stop timer. self._timer: {}'.format(self._timer))
if self._timer:
tt = self._total_time
et = self._elapsed
dt = tt - et
self.info('Estimated total time= {:0.1f}, elapsed time= {:0.1f}, deviation= {:0.1f}'.format(tt, et, dt))
self._timer.stop()
def reset(self):
# self._start_time = None
self._post = None
self.nruns_finished = 0
self._elapsed = 0
self._run_elapsed = 0
self._run_start = 0
def update_run_duration(self, run, t):
a = self.duration_tracker
a.update(run, t)
def start_run(self, run):
self._run_start = time.time()
self.setup_run_clock(run)
self.current_run_duration = self.get_run_duration(run.spec, as_str=True)
def get_run_duration(self, run, as_str=False):
sh = run.script_hash
if sh in self.duration_tracker:
self.debug('using duration tracker value')
rd = self.duration_tracker[sh]
else:
rd = run.get_estimated_duration(force=True)
rd = round(rd)
if as_str:
rd = str(timedelta(seconds=rd))
self.debug('run duration: {}'.format(rd))
return rd
def finish_run(self):
self._run_start = 0
self.nruns_finished += 1
self.debug('finish run. runs completed={}'.format(self.nruns_finished))
if self.clock:
self.clock.stop()
def continue_run(self):
if self.clock:
self.clock.finish_slice()
def setup_run_clock(self, run):
if self.use_clock:
ctx = run.spec.make_script_context()
extraction_slice = run.extraction_script.calculate_estimated_duration(ctx)
measurement_slice = run.measurement_script.calculate_estimated_duration(ctx)
def convert_hexcolor_to_int(c):
c = c[1:]
# func = lambda i: int(c[i:i + 2], 16)
# return list(map(func, (0, 2, 4)))
return [int(c[i:i + 2], 16) for i in (0, 2, 4)]
# ec, mc = list(map(convert_hexcolor_to_int,
# (EXTRACTION_COLOR, MEASUREMENT_COLOR)))
ec, mc = convert_hexcolor_to_int(EXTRACTION_COLOR), convert_hexcolor_to_int(MEASUREMENT_COLOR)
self.clock.set_slices([extraction_slice, measurement_slice],
[ec, mc])
self.clock.start()
# private
def _calculate_duration(self, runs):
dur = 0
if runs:
script_ctx = dict()
warned = []
ni = len(runs)
btw = 0
run_dur = 0
d = 0
for a in runs:
sh = a.script_hash
if sh in self.duration_tracker:
# t = a.make_truncated_script_hash()
# if a.has_conditionals() and t in self.duration_tracker:
# run_dur += self.duration_tracker.probability_model(sh, t)
# else:
# run_dur += self.duration_tracker[sh]
run_dur += self.duration_tracker[sh]
else:
run_dur += a.get_estimated_duration(script_ctx, warned, True)
d = a.get_delay_after(self.delay_between_analyses, self.delay_after_blank, self.delay_after_air)
btw += d
# subtract the last delay_after because experiment doesn't delay after last analysis
btw -= d
dur = run_dur + self.delay_before_analyses + btw
self.debug('nruns={} before={}, run_dur={}, btw={}'.format(ni, self.delay_before_analyses,
run_dur, btw))
return dur
def _get_run_elapsed(self):
return str(timedelta(seconds=self._run_elapsed))
def _get_elapsed(self):
return str(timedelta(seconds=self._elapsed))
def _get_total_time(self):
dur = timedelta(seconds=round(self._total_time))
return str(dur)
def _get_remaining(self):
if not self._total_time:
dur = NULL_STR
else:
dur = timedelta(seconds=round(self._total_time - self._elapsed))
return str(dur)
class ExperimentStats(Loggable):
elapsed = Property(depends_on='_elapsed')
_elapsed = Float
nruns = Int
nruns_finished = Int
etf = String
time_at = String
total_time = Property(depends_on='_total_time')
_total_time = Float
_timer = Any
delay_between_analyses = Float
delay_before_analyses = Float
_start_time = None
use_clock = Bool(False)
clock = Instance(PieClockModel, ())
# experiment_queue = Any
def calculate_duration(self, runs=None):
# if runs is None:
# runs = self.experiment_queue.cleaned_automated_runs
dur = self._calculate_duration(runs)
# add an empirical fudge factor
# ff = polyval(FUDGE_COEFFS, len(runs))
self._total_time = dur # + ff
return self._total_time
# def calculate_etf(self):
# runs = self.experiment_queue.cleaned_automated_runs
# dur = self._calculate_duration(runs)
# self._total_time = dur
# self.etf = self.format_duration(dur)
def format_duration(self, dur):
dt = (datetime.datetime.now() + \
datetime.timedelta(seconds=int(dur)))
return dt.strftime('%I:%M:%S %p %a %m/%d')
def _calculate_duration(self, runs):
dur = 0
if runs:
script_ctx = dict()
warned = []
ni = len(runs)
run_dur = sum([a.get_estimated_duration(script_ctx, warned, True) for a in runs])
btw = self.delay_between_analyses * (ni - 1)
dur = run_dur + btw + self.delay_before_analyses
self.debug('before={}, run_dur={}, btw={}'.format(self.delay_before_analyses,
run_dur, btw))
return dur
def _get_elapsed(self):
return str(datetime.timedelta(seconds=self._elapsed))
def _get_total_time(self):
dur = datetime.timedelta(seconds=round(self._total_time))
return str(dur)
def traits_view(self):
v = View(VGroup(
Item('nruns',
label='Total Runs',
style='readonly'),
Item('nruns_finished',
label='Completed',
style='readonly'),
Item('total_time',
style='readonly'),
Item('time_at', style='readonly'),
Item('etf', style='readonly', label='Est. finish'),
Item('elapsed',
style='readonly')),
UItem('clock', style='custom', width=100, height=100, defined_when='use_clock'))
return v
def start_timer(self):
st = time.time()
self._start_time = st
def update_time():
e = round(time.time() - st)
self.trait_set(_elapsed=e)
self._timer = Timer(1000, update_time)
self._timer.start()
def stop_timer(self):
if self._timer:
tt = self._total_time
et = self._elapsed
dt = tt - et
self.info('Estimated total time= {:0.1f}, elapsed time= {:0.1f}, deviation= {:0.1f}'.format(tt, et, dt))
self._timer.stop()
def reset(self):
self._start_time = None
self.nruns_finished = 0
self._elapsed = 0
def finish_run(self):
self.nruns_finished += 1
if self.clock:
self.clock.stop()
def continue_run(self):
if self.clock:
self.clock.finish_slice()
def setup_run_clock(self, run):
if self.use_clock:
ctx = run.spec.make_script_context()
extraction_slice = run.extraction_script.calculate_estimated_duration(ctx)
measurement_slice = run.measurement_script.calculate_estimated_duration(ctx)
def convert_hexcolor_to_int(c):
c = c[1:]
func = lambda i: int(c[i:i + 2], 16)
return map(func, (0, 2, 4))
ec, mc = map(convert_hexcolor_to_int,
(EXTRACTION_COLOR, MEASUREMENT_COLOR))
self.clock.set_slices([extraction_slice, measurement_slice],
[ec, mc])
self.clock.start()
class ExperimentStats(Loggable):
elapsed = Property(depends_on='_elapsed')
_elapsed = Float
nruns = Int
nruns_finished = Int
etf = String
time_at = String
total_time = Property(depends_on='_total_time')
_total_time = Float
_timer = Any
delay_between_analyses = Float
delay_before_analyses = Float
_start_time = None
# experiment_queue = Any
def calculate_duration(self, runs=None):
# if runs is None:
# runs = self.experiment_queue.cleaned_automated_runs
dur = self._calculate_duration(runs)
# add an empirical fudge factor
# ff = polyval(FUDGE_COEFFS, len(runs))
self._total_time = dur # + ff
return self._total_time
# def calculate_etf(self):
# runs = self.experiment_queue.cleaned_automated_runs
# dur = self._calculate_duration(runs)
# self._total_time = dur
# self.etf = self.format_duration(dur)
def format_duration(self, dur):
dt = (datetime.datetime.now() + \
datetime.timedelta(seconds=int(dur)))
return dt.strftime('%I:%M:%S %p %a %m/%d')
def _calculate_duration(self, runs):
dur = 0
if runs:
script_ctx = dict()
warned = []
ni = len(runs)
dur = sum([a.get_estimated_duration(script_ctx, warned) for a in runs])
btw = (self.delay_between_analyses * ni)
dur += btw + self.delay_before_analyses
return dur
def _get_elapsed(self):
return str(datetime.timedelta(seconds=self._elapsed))
def _get_total_time(self):
dur = datetime.timedelta(seconds=round(self._total_time))
return str(dur)
def traits_view(self):
v = View(VGroup(
Item('nruns',
label='Total Runs',
style='readonly'
),
Item('nruns_finished',
label='Completed',
style='readonly'
),
Item('total_time',
style='readonly'),
Item('time_at', style='readonly'),
Item('etf', style='readonly', label='Est. finish'),
Item('elapsed',
style='readonly'),
)
)
return v
def start_timer(self):
st = time.time()
self._start_time = st
def update_time():
e = round(time.time() - st)
self.trait_set(_elapsed=e)
self._timer = Timer(1000, update_time)
self._timer.start()
def stop_timer(self):
if self._timer:
tt = self._total_time
et = self._elapsed
dt = tt - et
self.info('Estimated total time= {:0.1f}, elapsed time= {:0.1f}, deviation= {:0.1f}'.format(tt, et, dt))
self._timer.stop()
def reset(self):
self._start_time = None
self.nruns_finished = 0
self._elapsed = 0
