def timeTrial(n):
a = stdarray.create1D(n, 0)
for i in range(n):
a[i] = stdrandom.uniformInt(-1000000, 1000000)
watch = Stopwatch()
count = threesum.countTriples(a)
return watch.elapsedTime()
def timeTrial(n):
a = stdarray.create1D(n, 0)
for i in range(n):
a[i] = stdrandom.uniformInt(-1000000, 1000000)
watch = Stopwatch()
count = threesum.countTriples(a)
return watch.elapsedTime()
def testDuration(self):
"""Tests that the duration results works as expected"""
stopwatch = Stopwatch()
time.sleep(1)
stopwatch.stop()
self.assertTrue(stopwatch.duration >= 1)
def new(self):
# start a new game
self.timer = Stopwatch()
self.all_sprites = pg.sprite.Group()
self.platforms = pg.sprite.Group()
self.enemies = pg.sprite.Group()
self.player = Player(self)
self.all_sprites.add(self.player)
self.last_update = 0
pg.mixer.music.load(path.join(SOUND, GAME_TRACK))
pg.mixer.music.play(LOOP)
pg.mixer.music.set_volume(0.6)
self.pausedtime = 0
# Enemies
for i in range(0):
m = Enemy(self)
self.all_sprites.add(m)
self.enemies.add(m)
# Platforms
for plat in PLATFORM_LIST:
p = Platform(self, *plat)
self.all_sprites.add(p)
self.platforms.add(p)
# Other platforms
self.run()
class CountingStopwatch2:
""" This counting stopwatch uses composition instead of
inheritance. """
def __init__(self):
# Create a stopwatch object to keep the time
self.watch = Stopwatch()
# Set number of starts to zero
self._count = 0
def start(self):
# Count this start message unless the watch already is running
if not self.watch._running:
self._count += 1
# Delegate other work to the stopwatch object
self.watch.start()
def stop(self):
# Delegate to stopwatch object
self.watch.stop()
def reset(self):
# Let the stopwatch object reset the time
watch.reset()
# Reset the count
self._count = 0
def elapsed(self):
# Delegate to stopwatch object
return self.watch.elapsed()
def count(self):
return self._count
def test_sanity(self):
lock1 = threading.RLock()
lock2 = threading.RLock()
def sleep_and_inc(lock,sleep_time):
with synchronize_using(lock):
time.sleep(sleep_time)
lock.sync_test_counter = getattr(lock,'sync_test_counter',0) + 1
sleep_time = 0.5
n = 4
s = Stopwatch()
lst_threads = []
for lock in [lock1,lock2]:
for _ in xrange(n):
t = threading.Thread(target=sleep_and_inc,args=[lock,sleep_time])
lst_threads.append(t)
t.start()
# wait for all threads, then check results
for t in lst_threads:
t.join()
duration = s.duration()
self.assertEqual(lock1.sync_test_counter,n)
self.assertEqual(lock2.sync_test_counter,n)
ideal_time = n*sleep_time
self.assert_(ideal_time*0.9 < duration < ideal_time*1.1, "duration=%s, ideal=%s" % (duration,ideal_time))
class Game:
def __init__(self, resources: Resources) -> None:
self.camera = Vector2d(0, 0)
self.stopwatch = Stopwatch(resources)
# Objective 4: Create a Player
# YOUR CODE HERE...
# Objective 5: Create a Map
# YOUR CODE HERE...
def update(self, controller: Controller) -> None:
if controller.has_input(Input.RESTART):
self.stopwatch.reset()
# Objective 4: Put the player back at the start
# YOUR CODE HERE...
# Objective 6: Call the player update method
# YOUR CODE HERE...
# Objective 7: Call the move_camera function with a focus on the player position
# YOUR CODE HERE...
# Objective 8: Update the stopwatch according to the player tile
# YOUR CODE HERE...
def render(self, renderer: Renderer) -> None:
# Objective 4: Render the player
# YOUR CODE HERE...
# Objective 5: Render the tilemap
# YOUR CODE HERE...
self.stopwatch.render(renderer)
def GetDataForCatsFromServer(cat, desc, orgId, orgName, action):
#action = 'GetData'
#action = 'GetDataTest'
reqUrl = base_url + '/api/Search/' + action #GetData
SearchDataRequest = {
'ContextTypes': 'Organization',
'BuiltInCategories': [cat],
'Version': '2019',
'OrgId': orgId
}
sw = Stopwatch()
while True:
verbose = False
if verbose:
print("before GetData", SearchDataRequest['BuiltInCategories'], desc, reqUrl )
r = requests.post( reqUrl, json = SearchDataRequest, headers=headers)
if r.status_code == 200:
break
print("after GetData", r.status_code, orgId, orgName)
if r.status_code == 401:
ensureLogin()
else:
print(r.text)
raise
break # or even throw?
sw = Stopwatch() # start new stopwatch.
m = sw.measure(silent=True)
return (r,m)
class RaisArmTime(Command):
def __init__(self, robot, raise_speed, stop_time, name=None, timeout=None):
'''
Constructor
'''
super().__init__(name, timeout)
self._robot = robot
self._raise_speed = raise_speed
self._stop_time = stop_time
self.requires(robot.arm)
self._stopwatch = Stopwatch()
def initialize(self):
"""Called before the Command is run for the first time."""
self._stopwatch.start()
def execute(self):
"""Called repeatedly when this Command is scheduled to run"""
self._robot.arm.move_arm(self._raise_speed)
def isFinished(self):
"""Returns true when the Command no longer needs to be run"""
return self._stopwatch.elapsed_time_in_secs() >= self._stop_time
def end(self):
"""Called once after isFinished returns true"""
self._robot.arm.move_arm(0)
def interrupted(self):
"""Called when another command which requires one or more of the same subsystems is scheduled to run"""
self.end()
def __init__(self, model, device):
ie = IECore()
model_xml = model
model_bin = os.path.splitext(model_xml)[0] + ".bin"
net = IENetwork(model=model_xml, weights=model_bin)
for input_key in net.inputs:
if len(net.inputs[input_key].layout) == 4:
self.n, self.c, self.h, self.w = net.inputs[input_key].shape
assert (len(net.inputs.keys()) == 1 or len(net.inputs.keys())
== 2), "Sample supports topologies only with 1 or 2 inputs"
self.out_blob = next(iter(net.outputs))
self.input_name, input_info_name = "", ""
for input_key in net.inputs:
if len(net.inputs[input_key].layout) == 4:
self.input_name = input_key
net.inputs[input_key].precision = 'U8'
elif len(net.inputs[input_key].layout) == 2:
input_info_name = input_key
net.inputs[input_key].precision = 'FP32'
if net.inputs[input_key].shape[1] != 3 and net.inputs[input_key].shape[1] != 6 or \
net.inputs[input_key].shape[0] != 1:
print(
'Invalid input info. Should be 3 or 6 values length.')
self.data = {}
if input_info_name != "":
infos = np.ndarray(shape=(self.n, self.c), dtype=float)
for i in range(self.n):
infos[i, 0] = self.h
infos[i, 1] = self.w
infos[i, 2] = 1.0
self.data[input_info_name] = infos
output_name, output_info = "", net.outputs[next(
iter(net.outputs.keys()))]
for output_key in net.outputs:
if net.layers[output_key].type == "DetectionOutput":
output_name, output_info = output_key, net.outputs[output_key]
if output_name == "":
print("Can't find a DetectionOutput layer in the topology")
output_dims = output_info.shape
if len(output_dims) != 4:
print("Incorrect output dimensions for SSD model")
max_proposal_count, object_size = output_dims[2], output_dims[3]
if object_size != 7:
print("Output item should have 7 as a last dimension")
output_info.precision = "FP32"
self.exec_net = ie.load_network(network=net, device_name=device)
self.watch = Stopwatch()
def __init__(self, model):
# Initialize TRT environment
self.input_shape = (300, 300)
trt_logger = trt.Logger(trt.Logger.INFO)
trt.init_libnvinfer_plugins(trt_logger, '')
with open(model, 'rb') as f, trt.Runtime(trt_logger) as runtime:
engine = runtime.deserialize_cuda_engine(f.read())
self.host_inputs = []
self.cuda_inputs = []
self.host_outputs = []
self.cuda_outputs = []
self.bindings = []
self.stream = cuda.Stream()
for binding in engine:
size = trt.volume(
engine.get_binding_shape(binding)) * engine.max_batch_size
host_mem = cuda.pagelocked_empty(size, np.float32)
cuda_mem = cuda.mem_alloc(host_mem.nbytes)
self.bindings.append(int(cuda_mem))
if engine.binding_is_input(binding):
self.host_inputs.append(host_mem)
self.cuda_inputs.append(cuda_mem)
else:
self.host_outputs.append(host_mem)
self.cuda_outputs.append(cuda_mem)
self.context = engine.create_execution_context()
self.watch = Stopwatch()
def test_n_threads(self):
sleep_time = 0.1
class Sleeper(object):
def __init__(self):
self._lock = threading.RLock() # used by @synchronized decorator
self.i = 0
self.thread_ids = set()
@synchronized
def _critical_section(self):
self.thread_ids.add(id(threading.currentThread()))
self.i += 1
def sleep(self):
time.sleep(sleep_time)
self._critical_section()
n_threads = 5
n_calls = 20
ao = AO.AO(Sleeper(), n_threads)
ao.start()
self.aos_to_stop.append(ao)
s = Stopwatch()
futures = [ao.sleep() for i in xrange(n_calls)]
for f in futures:
f.get()
duration = s.duration()
expected = sleep_time * n_calls / float(n_threads)
self.assert_(0.9 * expected < duration < 1.2 * expected, "duration=%s, expected=%s" % (duration, expected))
self.assertEqual(ao.obj.i, n_calls)
self.assertEqual(len(ao.obj.thread_ids), n_threads)
self.failIf(id(threading.currentThread()) in ao.obj.thread_ids)
def run(self, img, step=None, debug=False, print_time=False, filename='unknown'):
self.debug_out_list = []
self.source = img
funcs_to_run = self.functions[:step]
output = self.source
stopwatch = Stopwatch()
log_string = '{}\t{: <16}\t{:.04f}s {:.02f} fps'
for func in funcs_to_run:
if debug:
output, output_debug = func.run(debug, input=output)
self.debug_out_list.append(output_debug)
else:
output = func.run(debug, input=output)
t = stopwatch.round()
if print_time:
fps = 1 / t if t != 0 else 999
print(log_string.format(filename, str(func), t, fps))
t = stopwatch.total()
fps = 1 / t if t != 0 else 999
print(Fore.YELLOW + log_string.format(filename, 'TOTAL', t, fps) + Fore.RESET)
print() if print_time else None
if debug:
return self.debug_out_list[-1]
else:
return output
def do_GET(self):
if 0:
self.send_response(200)
self.end_headers()
self.wfile.write(b'fast')
return
watch = Stopwatch()
global ourData
try:
args = self.path.split('?')
if len(args)<2:
print("no size arg", args)
return
sizearg = int(args[1])
front = '[%s]\n' % sizearg
except Exception as e:
self.send_response(500)
self.end_headers()
err_out = str(e).encode()
self.wfile.write(err_out)
return
self.send_response(200)
self.end_headers()
self.wfile.write(front.encode())
#print('len:', len(ourData.slices.get(sizearg,'missing')))
self.wfile.write( ourData.slices.get(sizearg,'missing') )
watch.measure()
def add_widgets(self):
# Tabbed view
self.notebook = ttk.Notebook(self)
self.notebook.pack(fill=tk.BOTH, expand=1)
self.notebook.bind("<<NotebookTabChanged>>", self.manage_threads)
# First Tab: Alarms
self.alarms = Alarms(self.notebook)
self.protocol("WM_DELETE_WINDOW", self.on_close)
self.alarms.pack(fill=tk.BOTH, expand=1)
self.notebook.add(self.alarms, text="Alarms")
# Second Tab: Clock (Hopefully will add analog and digital)
self.clock = Clock(self.notebook)
self.clock.pack(fill=tk.BOTH, expand=1)
self.notebook.add(self.clock, text="Clock")
# Third Tab: Stopwatch
self.stopwatch = Stopwatch(self.notebook)
self.stopwatch.pack(fill=tk.BOTH, expand=1)
self.notebook.add(self.stopwatch, text="Stopwatch")
# Fourth Tab: Timer
self.timer = Timer(self.notebook)
self.timer.pack(fill=tk.BOTH, expand=1)
self.notebook.add(self.timer, text="Timer")
def __init__(self, robot, duration, speed, name=None, timeout=15):
"""Constructor"""
super().__init__(name, timeout)
self.robot = robot
self.requires(robot.drivetrain)
self._stopwatch = Stopwatch()
self._duration = duration
self._speed = speed
async def help(ctx: commands.Context):
Console.printc(f"user: {ctx.author} Started help", Fore.LIGHTBLUE_EX)
sw = Stopwatch()
await ctx.send(f"Help: ```{tabulate(HELP_LIST, headers=[' ', ' '], stralign='left', tablefmt='plain')}```")
Console.log("SYS (help)", f"Total time taken: {round(sw.duration * 1000)} ms")
sw.reset()
async def version(ctx: commands.Context):
Console.printc(f"user: {ctx.author} Started version", Fore.LIGHTBLUE_EX)
sw = Stopwatch()
await send_msg(ctx, f"```yaml\nVersion: {VERSION}\n```")
Console.log("SYS (version)", f"Total time taken: {round(sw.duration * 1000)} ms")
sw.reset()
def testDigits(self):
"""Tests that the string contains the correct precision"""
stopwatch = Stopwatch(4)
time.sleep(1)
stopwatch.stop()
# e.g 5.7282s
self.assertTrue(len(str(stopwatch)) == 7)
def time_trial(n):
a = []
for i in range(0, n):
a.append(random.randint(-MAXIMUM_INTEGER, MAXIMUM_INTEGER))
stopwatch = Stopwatch()
ThreeSum.count(a)
return stopwatch.elapsed_time()
def __init__(self, resources: Resources) -> None:
self.camera = Vector2d(0, 0)
self.stopwatch = Stopwatch(resources)
# Objective 4: Create a Player
self.player = Player(resources)
# Objective 5: Create a Map
self.map = Map(resources)
def test_no_sync(self):
stopwatch = Stopwatch()
threading.Thread(target=self.s.add,args=[10]).start()
time.sleep(0.05) # make sure other thread gets head start
val = self.s.add(5)
self.assertEqual(val,0)
duration = stopwatch.duration()
self.assert_(duration < 1.2*self.s.sleep_time, 'calls took too long. duration=%s' % duration)
def testStop(self):
"""Tests stopwatch's stopped state"""
stopwatch = Stopwatch()
stopwatch.stop()
now = str(stopwatch)
time.sleep(0.1)
after = str(stopwatch)
# A stopped stopwatch should not move
self.assertEqual(now, after)
def test_normal(self):
stopwatch = Stopwatch()
threading.Thread(target=self.s.sync_add,args=[10]).start()
time.sleep(0.05) # make sure other thread gets head start (and the mutex)
val = self.s.sync_add(5)
self.assertEqual(val,10)
duration = stopwatch.duration()
self.assert_(duration > 1.9*self.s.sleep_time, 'calls completed too quickly. duration=%s' % duration)
def timeTrials(f, n, trials):
total = 0.0
a = stdarray.create1D(n, 0.0)
for t in range(trials):
for i in range(n):
a[i] = stdrandom.uniformFloat(0.0, 1.0)
watch = Stopwatch()
f(a)
total += watch.elapsedTime()
return total
def main():
killhandler = KillHandler()
reddit = praw.Reddit(client_id=config.client_id,
client_secret=config.client_secret,
username=config.username,
password=config.password,
user_agent=config.user_agent)
logging.info("Starting checking submissions...")
stopwatch = Stopwatch()
while not killhandler.killed:
try:
for submission in reddit.subreddit('+'.join(
config.subreddits)).stream.submissions(skip_existing=True):
duration = stopwatch.measure()
logging.info(f"New submission: {submission}")
logging.info(f" -- retrieved in {duration:5.2f}s")
# We don't need to post a sticky on stickied posts
if submission.stickied:
logging.info(f" -- skipping (stickied)")
continue
# Post a comment to let people know where to invest
bot_reply = submission.reply_wrap(message.invest_place_here)
# Sticky the comment
if config.is_moderator:
bot_reply.mod.distinguish(how='yes', sticky=True)
# Measure how long processing took
duration = stopwatch.measure()
logging.info(f" -- processed in {duration:5.2f}s")
if killhandler.killed:
logging.info("Termination signal received - exiting")
break
except prawcore.exceptions.OAuthException as e_creds:
traceback.print_exc()
logging.error(e_creds)
logging.critical("Invalid login credentials. Check your .env!")
logging.critical(
"Fatal error. Cannot continue or fix the problem. Bailing out..."
)
exit()
except Exception as e:
logging.error(e)
traceback.print_exc()
time.sleep(10)
def testStopwatch(self):
"""Tests stopwatch timing"""
stopwatch = Stopwatch()
time.sleep(0.1)
stopwatch.stop()
m = str(stopwatch)
# Can't gurantee exact timings as python speed may differ each execution
# so ensure it is atleast a 100ms
# also a test for friendly time string
self.assertTrue(m.startswith("100") and m.endswith("ms"))
async def constructors_standings(ctx: commands.Context):
Console.printc(f"user: {ctx.author} Started constructors_standings", Fore.LIGHTBLUE_EX)
sw = Stopwatch()
cs = API.Get.constructor_standings()
Console.log("constructors_standings", cs)
await send_msg(ctx, f"Constructors Standings:\n```{cs}```")
Console.log("SYS (constructors_standings)", f"Total time taken: {round(sw.duration * 1000)} ms")
sw.reset()
async def calendar(ctx: commands.Context):
Console.printc(f"user: {ctx.author} Started calendar", Fore.LIGHTBLUE_EX)
sw = Stopwatch()
_calendar = API.Get.calendar()
Console.log("calendar", _calendar)
await send_msg(ctx, f"Calendar:\n```{_calendar}```")
Console.log("SYS (calendar)", f"Total time taken: {round(sw.duration * 1000)} ms")
sw.reset()
async def driver_standings(ctx: commands.Context):
Console.printc(f"user: {ctx.author} Started driver_standings", Fore.LIGHTBLUE_EX)
sw = Stopwatch()
ds = API.Get.driver_standings()
Console.log("driver_standings", ds)
await send_msg(ctx, f"Driver Standings:\n```{ds}```")
Console.log("SYS (driver_standings)", f"Total time taken: {round(sw.duration * 1000)} ms")
sw.reset()
async def last_qualifying_results(ctx: commands.Context):
Console.printc(f"user: {ctx.author} Started last_qualifying_results", Fore.LIGHTBLUE_EX)
sw = Stopwatch()
lqr = API.Get.last_qualifying_results()
Console.log("last_qualifying_results", lqr[1])
await send_msg(ctx, f"Last Qualifying Results: {lqr[0]}\n```{lqr[1]}```")
Console.log("SYS (last_qualifying_results)", f"Total time taken: {round(sw.duration * 1000)} ms")
sw.reset()
async def following_week(ctx: commands.Context):
Console.printc(f"user: {ctx.author} Started following_week", Fore.LIGHTBLUE_EX)
sw = Stopwatch()
race_info = f"Following Week:\n```json\n{API.Get.next_week()}```"
Console.log("following_week", race_info)
await send_msg(ctx, race_info)
Console.log("SYS (following_week)", f"Total time taken: {round(sw.duration * 1000)} ms")
sw.reset()
async def current(ctx: commands.Context):
Console.printc(f"user: {ctx.author} Started current", Fore.LIGHTBLUE_EX)
sw = Stopwatch()
race_info = f"```json\n{API.Get.current()}```"
Console.log("current", race_info)
await send_msg(ctx, race_info)
Console.log("SYS (current)", f"Total time taken: {round(sw.duration * 1000)} ms")
sw.reset()
def test_timeout(self):
# preset future - should return within timeout
f = future.Future.preset(3)
self.assertEqual(f.get(100),3)
# unset future - should raise exception
timeout = 1 # timeout in seconds
f = future.Future()
stopwatch = Stopwatch()
stopwatch.start()
self.assertRaises(future.FutureTimeoutException,f.get,timeout*1000)
duration = stopwatch.duration()
self.assert_(0.9*timeout < duration < 1.3*timeout, 'duration=%s' % duration)
def doDB_Work(limit=9999):
dbServer = r'jg-pc\jg1'
dbName = 'Ajour_System_A/S_10aee6e8b7dd4f4a8fd0cbf9cedf91cb'
theDBCfg = { 'server': dbServer, 'db': dbName, 'user': '******', 'pwd': 'morOg234' }
with getConn(theDBCfg) as conn:
csr = conn.cursor()
sw = Stopwatch()
a = selectFromDB(csr)
sw.measure()
print(len(a))
async def uptime(ctx: commands.Context):
global START_TIME
Console.printc(f"user: {ctx.author} Started uptime", Fore.LIGHTBLUE_EX)
sw = Stopwatch()
timedelta = datetime.now() - START_TIME
Console.log("uptime", f"Uptime: {timedelta}")
await send_msg(ctx, f"Uptime: ```json\n{timedelta}```")
Console.log("SYS (uptime)", f"Total time taken: {round(sw.duration * 1000)} ms")
sw.reset()
async def _ping(self, ctx):
stopwatch_banco = Stopwatch()
async with self.bot.db_connection.acquire() as conn:
await conn.fetch('select version();')
stopwatch_banco.stop()
e1 = discord.Embed(
title=f'Calculando ping {self.bot.emoji("loading")}',
colour=discord.Colour.random(),
timestamp=datetime.utcnow())
e1.set_footer(text=f'{ctx.author}',
icon_url=f'{ctx.author.avatar_url}')
stopwatch_message = Stopwatch()
mensagem_do_bot = await ctx.reply(embed=e1, mention_author=False)
stopwatch_message.stop()
e2 = discord.Embed(
title=
f'🏓 Latência da API: {prettify_number(int(self.bot.latency * 1000))}ms!\n'
f'{self.bot.emoji("database")} Tempo de resposta do banco: {stopwatch_banco}!\n'
f'📥 Tempo de resposta no discord: {stopwatch_message}!',
colour=discord.Colour.random(),
timestamp=datetime.utcnow())
e2.set_footer(text=f'{ctx.author}',
icon_url=f'{ctx.author.avatar_url}')
await asyncio.sleep(stopwatch_message.duration * 2)
await mensagem_do_bot.edit(
embed=e2,
allowed_mentions=discord.AllowedMentions(replied_user=False))
def getBCbyVsId(
vsId = 'B14462',
releaseId='624d9489-0f8c-48db-99f9-67701a040742'
):
global headers, url
bcUrl = url + '/api/v1/BuildingComponent/VSID/{vsId}/Release/{releaseId}'.format(vsId=vsId, releaseId=releaseId)
watch = Stopwatch('req')
r = requests.get( bcUrl, headers=headers)
watch.measure()
logIfBad(r)
exes = json.loads(r.text)
print(len(r.text))
if 0:
pprint.pprint(exes)
def evaluate(function, eval_func, test_perc=1.0, seed=0, **kwargs):
masks_path = 'data_test/paintings_gt/masks'
imgs_path = 'data_test/paintings_gt/imgs'
random.seed(seed)
all_imgs = all_files_in(imgs_path)
all_masks = all_files_in(masks_path)
dice_vals = []
tversky_vals = []
specificity_vals = []
presicion_vals = []
recall_vals = []
iou_vals = []
filenames = []
if test_perc == 1.0:
pairs = list(zip(all_imgs, all_masks))
else:
pairs = random.sample(list(zip(all_imgs, all_masks)),
int(len(all_imgs) * test_perc))
watch = Stopwatch()
for i, (paint_path, mask_path) in enumerate(pairs):
sys.stdout.write("\033[K")
filename = os.path.basename(paint_path)
mask = xml2img(mask_path)
if mask is None:
print(f' [{i + 1}/{len(pairs)}] ERROR "{filename}"', end='\r')
continue
paint = cv2.imread(paint_path)
out = function(paint, **kwargs)
# out = np.zeros_like(mask) + 255
dice, tversky, specificity, presicion, recall, iou = eval_func(
out, mask)
dice_vals.append(dice)
tversky_vals.append(tversky)
specificity_vals.append(specificity)
presicion_vals.append(presicion)
recall_vals.append(recall)
iou_vals.append(iou)
print(
f' [{i + 1}/{len(pairs)}] dice={mean(dice_vals):0.4f} tversky={mean(tversky_vals):0.4f} specificity={mean(specificity_vals):0.4f} presicion={mean(presicion_vals):0.4f} recall={mean(recall_vals):0.4f} iou={mean(iou_vals):0.4f} time={watch.total():.0f}s of "{filename}"',
end='\r')
sys.stdout.write("\033[K")
time = watch.total()
print(' '.join([f'({i}, {v:0.3f})' for i, v in enumerate(dice_vals, 1)]))
return dice_vals, filenames, mean(dice_vals), mean(tversky_vals), mean(
specificity_vals), mean(presicion_vals), mean(recall_vals), mean(
iou_vals), time
def compute_fitness(representation, chunk):
sw = Stopwatch()
sw.start()
score = 0
gene_ct = 0
covered_pts = set([])
for color in representation.keys():
lab_c1 = to_lab_color(color)
sw2 = Stopwatch()
sw2.start()
for allele in representation[color]:
gene_ct += 1
pts = allele.allele_pts()
for pt in pts:
pt_color = to_lab_color(TARGET_ARRAY[chunk][pt[0], pt[1]])
dist = color_distance(lab_c1, pt_color)
# print("pt {} draw {} dist {}".format(color, pt_color, dist))
score += 50 - dist
if pt in covered_pts:
score -= 1000
covered_pts.add(pt)
# print("color {}".format(sw2.reset()))
# score -= gene_ct ** 2
score -= (PAPER_WIDTH * PAPER_HEIGHT - len(covered_pts))
#print("fitness in {}".format(sw.reset()))
if gene_ct > 0:
return score
return -1e128
async def clear(ctx: commands.Context):
Console.printc(f"user: {ctx.author} Started clear", Fore.LIGHTBLUE_EX)
sw = Stopwatch()
messages = await ctx.message.channel.history().flatten()
Console.log(f"clear", f"Msg list length {len(messages)}")
for message in messages:
time.sleep(0.2) # To avoid rate limit
if message.author.bot or message.content[:len(USER_CFG.prefix)] == USER_CFG.prefix:
await message.delete()
Console.log("SYS (clear)", f"Total time taken: {round(sw.duration * 1000)} ms")
sw.reset()
def getBC_chunk(chunkSet):
global headers, url
bcUrl = url + '/api/v1/BuildingComponent/VSIDs/Release/624d9489-0f8c-48db-99f9-67701a040742?' + chunkSet #bcArgs
print(bcUrl)
#return
watch = Stopwatch('req')
r = requests.post( bcUrl, headers=headers)
watch.measure()
logIfBad(r)
exes = json.loads(r.text)
print('len:', len(r.text))
with open( 'BCs.json', "w") as outfile:
json.dump(exes, outfile, indent=2)
if 0:
pprint.pprint(exes)
def getBCs(
releaseId='624d9489-0f8c-48db-99f9-67701a040742'
):
global headers, url
bcUrl = url + '/api/v1/BuildingComponent/VSIDs/Release/{releaseId}?VSID1=B33321&VSID2=B96932&VSID3=B75326&VSID4=B36547&VSID5=B20553&VSID6=B59061&VSID7=B58491&VSID8=B80296&VSID9=B81223'.format(releaseId=releaseId)
print(bcUrl)
watch = Stopwatch('req')
r = requests.post( bcUrl, headers=headers)
watch.measure()
logIfBad(r)
exes = json.loads(r.text)
print(len(r.text))
with open( 'BCs.json', "w") as outfile:
json.dump(exes, outfile, indent=2)
if 0:
pprint.pprint(exes)
def getBCbyGroup( # get the BCs within a BC-group.
groupId = 'B14462',
releaseId='624d9489-0f8c-48db-99f9-67701a040742'
):
global headers, url
bcUrl = url + '/api/v1/BuildingComponent/BuildingComponentGroup/{groupId}/Release/{releaseId}'.format(groupId=groupId, releaseId=releaseId)
watch = Stopwatch('req')
r = requests.get( bcUrl, headers=headers)
watch.measure(show=False)
logIfBad(r)
exes = json.loads(r.text)
if 0:
print(len(r.text))
if 0:
pprint.pprint(exes)
exes = exes['buildingComponents']
return exes
def getPrices():
global headers, url
releaseID = '624d9489-0f8c-48db-99f9-67701a040742'
priceUrl = url + '/api/v1/BuildingComponent/Calculate/Release/%s?' % releaseID
priceUrl += 'id1=d03b8b89-fb70-47da-9a18-011132b22921&id2=32e920bb-e927-4a10-ad85-14c32bd197ff&id3=3dbf3ce5-f7e5-4745-bf18-1bd766c1b54d'
priceUrl += '&amount1=10&amount2=10&amount3=10'
priceUrl += "&yourCalculationId=1246" #{myRandomCalculationNumber}
print(priceUrl)
watch = Stopwatch('req')
r = requests.post( priceUrl, headers=headers)
watch.measure()
logIfBad(r)
prices = json.loads(r.text)
if 0:
pprint.pprint(prices)
with open( 'prices.json', "w") as outfile:
json.dump(prices, outfile, indent=2)
def getPrice_chunk(chunkSet, chunkIx):
global headers, url
releaseID = '624d9489-0f8c-48db-99f9-67701a040742'
priceUrl = url + '/api/v1/BuildingComponent/Calculate/Release/%s?' % releaseID
priceUrl += chunkSet
print(chunkIx, priceUrl)
#return
watch = Stopwatch('req')
r = requests.post( priceUrl, headers=headers)
watch.measure()
logIfBad(r)
prices = json.loads(r.text)
if 0:
pprint.pprint(prices)
with open( 'prices.json', "w") as outfile:
json.dump(prices, outfile, indent=2)
def init(self):
self.initStyles()
self.initMaps()
Terrain.initImages()
Terrain.initSounds()
self.initMenus()
self.stopwatch = Stopwatch()
self.initHelp()
self.mode = "menu"
self.menu = self.mainMenu
def GetToken_Password(): # oauth, exchange a password for a token.
global env, url
print(env['username'], env['password'])
tokenReq = {
'grant_type': 'password',
'username': env['username'], #+'2',
'password': env['password'],
'client_id': env['client_id'],
'client_secret': env['client_secret'] #+'2'
}
token_url = url + '/token'
print('before', token_url)
watch = Stopwatch('req')
r = requests.post(token_url, tokenReq)
watch.measure()
logIfBad(r)
return r
def __init__(self, robot, raise_speed, stop_time, name=None, timeout=None):
'''
Constructor
'''
super().__init__(name, timeout)
self._robot = robot
self._raise_speed = raise_speed
self._stop_time = stop_time
self.requires(robot.arm)
self._stopwatch = Stopwatch()
def __init__(self, name=None):
if name is None:
self._name_argument_string = ""
else:
self._name_argument_string = "(%s)" % name
self._fps_history = collections.deque(maxlen=10)
self._previous_time = None
self._previous_calculated_fps_time = None
self._stopwatch = Stopwatch()
self._fps = None
class FpsMeter:
print_fps = True
def __init__(self, name=None):
if name is None:
self._name_argument_string = ""
else:
self._name_argument_string = "(%s)" % name
self._fps_history = collections.deque(maxlen=10)
self._previous_time = None
self._previous_calculated_fps_time = None
self._stopwatch = Stopwatch()
self._fps = None
def update(self):
self._now = self._stopwatch.get_elapsed_time()
if self._previous_time is None:
self._stopwatch.start()
else:
self._update_fps_history()
self._update_fps_if_timely()
self._previous_time = self._now
def _update_fps_history(self):
time_increment = self._now - self._previous_time
fps = 1.0 / time_increment
self._fps_history.append(fps)
def _update_fps_if_timely(self):
if self._previous_calculated_fps_time:
if (self._stopwatch.get_elapsed_time() - self._previous_calculated_fps_time) > 1.0:
self._calculate_fps()
else:
self._calculate_fps()
def _calculate_fps(self):
self._fps = sum(self._fps_history) / len(self._fps_history)
if self.print_fps:
print "FPS%s: %.1f" % (self._name_argument_string, self._fps)
self._previous_calculated_fps_time = self._stopwatch.get_elapsed_time()
def get_fps(self):
return self._fps
def __init__(self, robot, duration, speed, ramp_threshold, name=None, timeout=None):
'''
Constructor
'''
super().__init__(name, timeout)
self.robot = robot;
self.requires(robot.drivetrain)
self._stopwatch = Stopwatch()
self._duration = duration
self._speed = speed
self._ramp_threshold = ramp_threshold
def __init__(self):
Behavior.__init__(self)
self._recall_amount = args.recall_amount
self.memorize = args.memorize
self.auto_friction = args.auto_friction
self._auto_switch_enabled = False
self.input_only = False
self._input = None
self._noise_amount = 0
self.reset_translation()
self._stopwatch = Stopwatch()
self._stopwatch.start()
def loadLevel(self):
terrain, self.startpos = self.maps.load(self.level)
self.terrain = pygame.sprite.Group(*terrain)
self.ball = Ball(*self.startpos)
self.score = 0
self.stopwatch.restart()
if self.level != "test":
highscore = self.progress[self.level]["score"]
bestTime = self.progress[self.level]["time"]
else:
highscore, bestTime = None, None
self.highscoreText = str(highscore) if highscore != None else "---"
if bestTime != None:
self.bestTimeText = Stopwatch.secToMin(bestTime)
else:
self.bestTimeText = "---"
def __init__(self, experiment):
QtGui.QMainWindow.__init__(self)
experiment.window = self
self._experiment = experiment
self._layout = QtGui.QVBoxLayout()
self.setLayout(self._layout)
self._add_parameter_form()
self._add_map_view()
self._create_menu()
self.stopwatch = Stopwatch()
self._frame_count = 0
timer = QtCore.QTimer(self)
timer.setInterval(1000. / FRAME_RATE)
QtCore.QObject.connect(timer, QtCore.SIGNAL('timeout()'), self._update)
timer.start()
class DriveTime(Command):
'''
classdocs
'''
_stopwatch = None
_start_time = None
_duration = None
_speed = None
_ramp_threshold = None
def __init__(self, robot, duration, speed, ramp_threshold, name=None, timeout=None):
'''
Constructor
'''
super().__init__(name, timeout)
self.robot = robot;
self.requires(robot.drivetrain)
self._stopwatch = Stopwatch()
self._duration = duration
self._speed = speed
self._ramp_threshold = ramp_threshold
def initialize(self):
"""Called before the Command is run for the first time."""
# Start stopwatch
self._stopwatch.start()
return Command.initialize(self)
def execute(self):
"""Called repeatedly when this Command is scheduled to run"""
speed = self._speed
time_left = self._duration - self._stopwatch.elapsed_time_in_secs()
if (time_left < self._ramp_threshold):
speed = speed * time_left / self._ramp_threshold
self.robot.drivetrain.arcade_drive(speed, 0.0)
return Command.execute(self)
def isFinished(self):
"""Returns true when the Command no longer needs to be run"""
# If elapsed time is more than duration
return self._stopwatch.elapsed_time_in_secs() >= self._duration
def end(self):
"""Called once after isFinished returns true"""
self._stopwatch.stop()
# Stop driving
self.robot.drivetrain.arcade_drive(0.0, 0.0)
def interrupted(self):
"""Called when another command which requires one or more of the same subsystems is scheduled to run"""
self.end()
def evaluate(self,times=None):
results = []
s = Stopwatch()
times = times if times != None else self._times
for i in range(times):
self._setup()
s.reset()
gc.disable()
s.start()
self._code()
gc.enable()
results.append(s.read())
self._evaluate_results = [(min(results),sum(results)/times,max(results))] + [results]
return self._evaluate_results
def __init__(self, master=None):
super().__init__(master)
# Initialize widgets
self.create_widgets()
# Create a Stopwatch interpreter
with open('stopwatch_external.yaml') as f:
statechart = import_from_yaml(f)
# Create a stopwatch object and pass it to the interpreter
self.stopwatch = Stopwatch()
self.interpreter = Interpreter(statechart, initial_context={'stopwatch': self.stopwatch})
self.interpreter.time = time.time()
# Run the interpreter
self.run()
# Update the stopwatch every 100ms
self.after(100, self.update_stopwatch)
def initLevelMenu(self):
top = 60
left = 130
entries = []
actions = []
for i, level in enumerate(self.maps.levels):
prevLevel = self.maps.levels[i - 1]
if i > 0 and self.progress[prevLevel]["score"] == None:
entries.append("Level %s Locked" % level)
actions.append(None)
continue
elif self.progress[level]["score"] == None:
entries.append("Level %s Unlocked" % level)
else:
entries.append("Level %s Highscore: %d Best time: %s" %
(level, self.progress[level]["score"],
Stopwatch.secToMin(self.progress[level]["time"])))
# Locally scope level
actions.append(lambda level=level: self.playLevel(level))
entries += ["Return to main menu", "Clear progress"]
actions += [self.doMainMenu, self.progress.clear]
self.levelMenu = Menu(left, top, entries, actions)
def __init__(self, args):
self.args = args
self.width = args.width
self.height = args.height
self.margin = args.margin
self.show_fps = args.show_fps
self.gl_display_mode = GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH
self._fullscreen = False
self.exiting = False
self._frames = []
self.time_increment = 0
self.stopwatch = Stopwatch()
self._frame_count = 0
self._set_camera_position(CAMERA_POSITION)
self._set_camera_orientation(CAMERA_Y_ORIENTATION, CAMERA_X_ORIENTATION)
self.fovy = 45
self.near = 0.1
self.far = 100.0
self._text_renderer_class = getattr(text_renderer_module, TEXT_RENDERERS[args.text_renderer])
if self.show_fps:
self.fps_history = collections.deque(maxlen=10)
self.previous_shown_fps_time = None