Python time.perf_counter() Examples

def simulate_component(self, compID):
        """
        Do simulation for the specified foreground component.
        """
        logger.info("==================================================")
        logger.info(">>> Simulate component: %s <<<" % compID)
        logger.info("==================================================")
        t1_start = time.perf_counter()
        t2_start = time.process_time()

        comp_cls = COMPONENTS_ALL[compID]
        comp_obj = comp_cls(self.configs)
        comp_obj.preprocess()
        skyfiles = comp_obj.simulate()
        if self.products:
            self.products.add_component(compID, skyfiles)
        comp_obj.postprocess()

        t1_stop = time.perf_counter()
        t2_stop = time.process_time()
        logger.info("--------------------------------------------------")
        logger.info("Elapsed time: %.1f [min]" % ((t1_stop-t1_start)/60))
        logger.info("CPU process time: %.1f [min]" % ((t2_stop-t2_start)/60))
        logger.info("--------------------------------------------------") 

def check_cooldowns(self, userid, action, settings):
        path = settings["Config"][action]
        if abs(settings["Players"][userid][action] - int(time.perf_counter())) >= path:
            settings["Players"][userid][action] = int(time.perf_counter())
            dataIO.save_json(self.file_path, self.system)
            return True
        elif settings["Players"][userid][action] == 0:
            settings["Players"][userid][action] = int(time.perf_counter())
            dataIO.save_json(self.file_path, self.system)
            return True
        else:
            s = abs(settings["Players"][userid][action] - int(time.perf_counter()))
            seconds = abs(s - path)
            remaining = self.time_formatting(seconds)
            await self.bot.say("This action has a cooldown. You still have:\n{}".format(remaining))
            return False 

def check_cooldowns(self, settings, userid):
        if abs(settings["Users"][userid]["Trade Cooldown"] - int(time.perf_counter())) \
                >= settings["Config"]["Trade Cooldown"]:
            settings["Users"][userid]["Trade Cooldown"] = int(time.perf_counter())
            dataIO.save_json(self.file_path, self.system)
            return "OK"
        elif settings["Users"][userid]["Trade Cooldown"] == 0:
            settings["Users"][userid]["Trade Cooldown"] = int(time.perf_counter())
            dataIO.save_json(self.file_path, self.system)
            return "OK"
        else:
            s = abs(settings["Users"][userid]["Trade Cooldown"] - int(time.perf_counter()))
            seconds = abs(s - settings["Config"]["Trade Cooldown"])
            msg = ("You must wait before trading again. "
                   "You still have: {}".format(self.time_format(seconds)))
            return msg 

def heist_game(self, settings, server, t_heist, t_crew, t_vault):
        crew = len(settings["Crew"])
        target = self.heist_target(settings, crew)
        settings["Config"]["Heist Start"] = True
        players = [server.get_member(x) for x in settings["Crew"]]
        results = self.game_outcomes(settings, players, target)
        start_output = self.message_handler(settings, crew, players)
        await self.bot.say("Get ready! The {} is starting with {}\nThe {} has decided to "
                           "hit **{}**.".format(t_heist, start_output, t_crew, target))
        await asyncio.sleep(3)
        await self.show_results(settings, results)
        if settings["Crew"]:
            players = [server.get_member(x) for x in settings["Crew"]]
            data = self.calculate_credits(settings, players, target)
            headers = ["Players", "Credits Obtained", "Bonuses", "Total"]
            t = tabulate(data, headers=headers)
            msg = ("The credits collected from the {} was split among the winners:\n```"
                   "C\n{}```".format(t_vault, t))
        else:
            msg = "No one made it out safe."
        settings["Config"]["Alert Time"] = int(time.perf_counter())
        self.reset_heist(settings)
        self.save_system()
        await self.bot.say(msg) 

def shutdown_save(self):
        for server in self.system["Servers"]:
            death_time = self.system["Servers"][server]["Config"]["Death Timer"]
            for player in self.system["Servers"][server]["Players"]:
                player_death = self.system["Servers"][server]["Players"][player]["Death Timer"]
                player_sentence = self.system["Servers"][server]["Players"][player]["Time Served"]
                sentence = self.system["Servers"][server]["Players"][player]["Sentence"]

                if player_death > 0:
                    s = abs(player_death - int(time.perf_counter()))
                    seconds = abs(s - death_time)
                    self.system["Servers"][server]["Players"][player]["Death Timer"] = seconds

                if player_sentence > 0:
                    s = abs(player_sentence - int(time.perf_counter()))
                    seconds = abs(s - sentence)
                    self.system["Servers"][server]["Players"][player]["Time Served"] = seconds 

def __init__(self, title = None, pathfile = None, debug_mode = True, debug_level = 0):
        self.path_file = pathfile
        self.debug_mode = debug_mode
        self.starttime = time.perf_counter()
        self.nowtime = time.perf_counter()
        self.lastcall = time.perf_counter() 
        self.debug_level = debug_level
        
        # create file?
#        if not isfile(self.path_file):
#            with open(self.path_file, 'w') as f:
#                f.write("-init log file-")
        
        if title is not None:
            today = datetime.datetime.now()   
            s = title + " program started the " + today.strftime("%d of %b %Y at %H:%M")
            self.log("=============================================================\n" +
                     s +
                     "\n=============================================================") 

def __call__(self, func, *args, **kwargs):
        '''Used to process callbacks in throughput-limiting thread
        through queue.
        Args:
            func (:obj:`callable`): the actual function (or any callable) that
                is processed through queue.
            *args: variable-length `func` arguments.
            **kwargs: arbitrary keyword-arguments to `func`.
        Returns:
            None
        '''
        if not self.is_alive() or self.__exit_req:
            raise DelayQueueError('Could not process callback in stopped thread')
        self._queue.put((func, args, kwargs))


# The most straightforward way to implement this is to use 2 sequenital delay
# queues, like on classic delay chain schematics in electronics.
# So, message path is:
# msg --> group delay if group msg, else no delay --> normal msg delay --> out
# This way OS threading scheduler cares of timings accuracy.
# (see time.time, time.clock, time.perf_counter, time.sleep @ docs.python.org) 

def benchmark(package_name):
    def decorator(func):
        def inner():
            try:
                package = import_module(package_name)
            except ImportError:
                return 'not available.'

            start = perf_counter()
            for i in range(TIMES):
                func(package)
            end = perf_counter()

            return end - start
        return inner
    return decorator 

def start_game(self):
        builtins.cfg = \
            chess_config.Config(self.config_name.lower(), self.crazy_mode)
        self.game._reset()
        agent1_module = __import__(self.agent1 + "_ChessPlayer")
        white_opponent_class = getattr(agent1_module,
            self.agent1 + "_ChessPlayer")
        self.white_opponent = white_opponent_class(self.game.board,'white')
        agent2_module = __import__(self.agent2 + "_ChessPlayer")
        black_opponent_class = getattr(agent2_module,
            self.agent2 + "_ChessPlayer")
        self.black_opponent = black_opponent_class(self.game.board,'black')
        self.game.white_player = self.agent1
        self.game.black_player = self.agent2
        self.player_time = {'white':0.0,'black':0.0}
        self.timer = time.perf_counter()
        move = self.take_player_turn()
        self.attempt_to_make_move(self.game.board[move[0]], *move)
        while self.game.started:
            move = self.switch_player_turn()
            self.attempt_to_make_move(self.game.board[move[0]], *move) 

def switch_player_turn(self, the_time):
        if self.do_replay:
            self.player_time[self.game.player_turn] = the_time
        else:
            time_against = time.perf_counter() - self.timer
            self.player_time[self.game.player_turn] += time_against
        self.player_time_label[self.game.player_turn]['text'] = \
            '{:.1f} sec'.format(self.player_time[self.game.player_turn])
        if self.player_time[self.game.player_turn] > cfg.TIME_LIMIT:
            self.player_time_label[self.game.player_turn]['foreground'] = 'red'

        self.turn_label['foreground'] = self.game.player_turn
        self.game.player_turn = \
            'black' if self.game.player_turn == 'white' else 'white'
        self.turn_label['text'] = self.game.player_turn.capitalize()
        self.turn_label['background'] = self.game.player_turn
        if not self.do_replay:
            if self.player_time[self.game.player_turn] > cfg.TIME_LIMIT:
                self.force_random_move()
            else:
                self.take_player_turn() 

def query(sql, **kwargs):
    ti = time.perf_counter()
    _query = text(sql).execution_options(autocommit=False)
    try:
        res = conn.execute(_query, **kwargs)
        ms = int((time.perf_counter() - ti) * 1000)
        QueryStats.log(sql, ms)
        if ms > 100:
            disp = re.sub('\s+', ' ', sql).strip()[:250]
            print("\033[93m[SQL][{}ms] {}\033[0m".format(ms, disp))
        logger.debug(res)
        return res
    except Exception as e:
        print("[SQL] Error in query {} ({})".format(sql, kwargs))
        conn.close()
        logger.exception(e)
        raise e

# n*m 

def __exec(self, method, *params):
        time_start = time.perf_counter()
        tries = 0
        while True:
            try:
                result = self._client.exec(method, *params)
                assert result, "empty response {}".format(result)
            except (AssertionError, RPCError) as e:
                tries += 1
                print("{} failure, retry in {}s -- {}".format(method, tries, e))
                time.sleep(tries)
                continue
            break

        batch_size = len(params[0]) if method == 'get_accounts' else 1
        total_time = int((time.perf_counter() - time_start) * 1000)
        ClientStats.log("%s()" % method, total_time, batch_size)
        return result

    # perform batch call (if jussi is enabled, use batches; otherwise, multi) 

def __exec_batch(self, method, params):
        time_start = time.perf_counter()
        result = None

        if self._jussi:
            tries = 0
            while True:
                try:
                    result = list(self._client.exec_batch(method, params, batch_size=500))
                    break
                except (AssertionError, RPCError) as e:
                    tries += 1
                    print("batch {} failure, retry in {}s -- {}".format(method, tries, e))
                    time.sleep(tries)
                    continue
        else:
            result = list(self._client.exec_multi_with_futures(
                method, params, max_workers=10))

        total_time = int((time.perf_counter() - time_start) * 1000)
        ClientStats.log("%s()" % method, total_time, len(params))
        return result 

def cache_accounts(cls, accounts):
        from hive.indexer.cache import batch_queries

        processed = 0
        total = len(accounts)

        for i in range(0, total, 1000):
            batch = accounts[i:i+1000]

            lap_0 = time.perf_counter()
            sqls = cls._generate_cache_sqls(batch)
            lap_1 = time.perf_counter()
            batch_queries(sqls)
            lap_2 = time.perf_counter()

            if len(batch) < 1000:
                continue

            processed += len(batch)
            rem = total - processed
            rate = len(batch) / (lap_2 - lap_0)
            pct_db = int(100 * (lap_2 - lap_1) / (lap_2 - lap_0))
            print(" -- account {} of {} ({}/s, {}% db) -- {}m remaining".format(
                processed, total, round(rate, 1), pct_db, round(rem / rate / 60, 2))) 

def update_ranks(cls):
        sql = """
        UPDATE hive_accounts
           SET rank = r.rnk
          FROM (SELECT id, ROW_NUMBER() OVER (ORDER BY vote_weight DESC) as rnk FROM hive_accounts) r
         WHERE hive_accounts.id = r.id AND rank != r.rnk;
        """
        query(sql)
        return

        # the following method is 10-20x slower
        id_weight = query_all("SELECT id, vote_weight FROM hive_accounts")
        id_weight = sorted(id_weight, key=lambda el: el[1], reverse=True)

        print("Updating account ranks...")
        lap_0 = time.perf_counter()
        query("START TRANSACTION")
        for (i, (_id, _)) in enumerate(id_weight):
            query("UPDATE hive_accounts SET rank=%d WHERE id=%d" % (i+1, _id))
        query("COMMIT")
        lap_1 = time.perf_counter()
        print("Updated %d ranks in %ds" % (len(id_weight), lap_1 - lap_0)) 

def ws_connect(self, url: str, timeout: float = None
                         ) -> WebSocketClientConnection:
        """Make WebSocket connection to the url.

        Retries up to _max (default: 20) times. Client connections made by this
        method are closed after each test method.
        """
        st = time.perf_counter()
        timeout = timeout or self.timeout
        while (time.perf_counter() - st) < timeout:
            try:
                ws = await to_asyncio_future(websocket_connect(url))
            except ConnectionRefusedError:
                await self.wait()
                continue
            else:
                self._ws_connections.append(ws)
                return ws
        raise ConnectionRefusedError(
            'WebSocket connection refused: {}'.format(url)) 

def do_work(job):
    tstart = time.perf_counter()

    status_code = None
    timeout = False
    connection_error = False
    expect_not_present = False

    try:
        result = requests.get(job.get('url'), timeout=job.get('timeout'))
        status_code = result.status_code

        if job.get('expect'):
            if job.get('expect') not in result.text:
                expect_not_present = True

    except ReadTimeout:
        timeout = True

    except socket_error:
        connection_error = True

    return {'status_code': status_code, 'ms': (time.perf_counter()-tstart)*1000, 'timeout': timeout,
            'connection_error': connection_error,
            'tstart': tstart, 'tstop': time.perf_counter(), 'expect_not_present': expect_not_present} 

def try_with_timeout(target, args, timeout, pause):
    """
    Attempt an operation as long as it fails up to the given timeout.
    :param target:  The callable
    :param args:    The arguments to pass
    :param timeout: the timeout
    :param pause:   how long to pause between each failed invocation
    :return: either the result from successfully invoking the callable
    raises the exception thrown by the callable on timeout.
    """
    end = time.perf_counter()+timeout
    result, exception = try_invoke(target, args)
    while exception is not None and time.perf_counter()<end:
        time.sleep(pause)
        result, exception = try_invoke(target, args)
    if exception is not None:
        raise exception
    return result 

def upload_blocks(bucket, chunk_size, max_threads, lines):
    session = botocore.session.get_session()
    client = session.create_client('s3')
    start = time.perf_counter()
    futures = []
    with ThreadPoolExecutor(max_workers=max_threads) as executor:
        # Start the load operations and mark each future with its URL
        for line in lines:
            raw_block, key = load_json_block(line)
            futures.append(executor.submit(client.put_object,Bucket=bucket,
                                 Key=key,
                                 Body=raw_block,
                                 ContentEncoding='UTF-8',
                                 ContentType='application/json'))
        end = time.perf_counter()

    done, pending = concurrent.futures.wait(futures)
    complete = time.perf_counter()
    rate = 1 / ((complete - start) / len(done))
    return len(done), int(rate) 

def __init__(self, signal_in=None, name="layer", print_fps=False, print_fps_every=timedelta(seconds=5),
                 *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.name = name
        self.counter = 0
        self.signal = None
        self.is_first = True
        self.stop_event = None
        self.signal_in = None
        self.set_signal_in(signal_in)

        self.count = 0
        self.start_time = None
        self.reset()
        self.print_fps_every = print_fps_every
        self.print_fps = print_fps
        self.fps = 0
        self.last_tick_time = time.perf_counter() 

def runPutTest(testDataPath, testDataRangeStart, testDataRangeEnd, f):
	log.debug('running put tests...')
	timeStart = time.perf_counter()
	times = [time.perf_counter()]
	for i in range(testDataRangeStart, testDataRangeEnd):
		print(i)
		thisPath = '%s/%i' % (testDataPath, i)
		o = loadTestData(thisPath)

		f.putObject(o, str(i))

		times.append(time.perf_counter())

	timeEnd = time.perf_counter()
	log.warning('RESULT (PUT): total test runtime: %s seconds, mean per object: %s' % (
		timeEnd - timeStart, ((timeEnd - timeStart) / testDataRangeEnd)))
	log.critical('RESULT (PUT): median result: %s ' % statistics.median(calculateTimeDeltas(times)))
	log.critical('RESULT (PUT): standard deviation result: %s ' % statistics.stdev(calculateTimeDeltas(times)))
	log.critical('RESULT (PUT): mean result: %s ' % statistics.mean(calculateTimeDeltas(times)))


# log.critical('RESULT (PUT): individual times: %s ' % (calculateTimeDeltas(times))) 

def runGetTest(testDataPath, testDataRangeStart, testDataRangeEnd, f):
	log.debug('running get tests...')
	timeStart = time.perf_counter()
	times = [time.perf_counter()]
	for i in range(testDataRangeStart, testDataRangeEnd):
		thisPath = '%s/%i' % (testDataPath, i)

		o = f.getObject(str(i))
		saveTestData(o, thisPath)

		times.append(time.perf_counter())

	timeEnd = time.perf_counter()
	log.critical('RESULT (GET): total test runtime: %s seconds, mean per object: %s' % (
		timeEnd - timeStart, ((timeEnd - timeStart) / testDataRangeEnd)))
	log.critical('RESULT (GET): median result: %s ' % statistics.median(calculateTimeDeltas(times)))
	log.critical('RESULT (GET): standard deviation result: %s ' % statistics.stdev(calculateTimeDeltas(times)))
	log.critical('RESULT (GET): mean result: %s ' % statistics.mean(calculateTimeDeltas(times)))


# log.critical('RESULT (GET): individual times: %s ' % (calculateTimeDeltas(times))) 

def runDeleteTest(testDataRangeStart, testDataRangeEnd, f):
	log.debug('running delete tests...')
	timeStart = time.perf_counter()
	times = [time.perf_counter()]
	for i in range(testDataRangeStart, testDataRangeEnd):
		f.deleteObject(str(i))

		times.append(time.perf_counter())

	timeEnd = time.perf_counter()
	log.critical('RESULT (DELETE): total test runtime: %s seconds, mean per object: %s' % (
		timeEnd - timeStart, ((timeEnd - timeStart) / testDataRangeEnd)))
	log.critical('RESULT (DELETE): median result: %s ' % statistics.median(calculateTimeDeltas(times)))
	log.critical('RESULT (DELETE): standard deviation result: %s ' % statistics.stdev(calculateTimeDeltas(times)))
	log.critical('RESULT (DELETE): mean result: %s ' % statistics.mean(calculateTimeDeltas(times)))


# log.critical('RESULT (DELETE): individual times: %s ' % (calculateTimeDeltas(times)))



###############################################################################
############################################################################### 

def gain_xp(self, message):
        user = message.author
        id = user.id
        if self.check_joined(id):
            if id in self.gettingxp:
                seconds = abs(self.gettingxp[id] - int(time.perf_counter()))
                if seconds >= self.cooldown:
                    self.add_xp(id)
                    self.gettingxp[id] = int(time.perf_counter())
                    fileIO("data/levels/leader_board.json", "save", self.leader_board)
                if self.leader_board[user.id]["XP"] >= self.get_level_xp(self.leader_board[user.id]["rank"]):
                    self.leader_board[user.id]["rank"] += 1
                    self.leader_board[user.id]["XP"] = 0
                    msg = '{} **has leveled up and is now level {}!!!\n HURRAY!!**'
                    msg = msg.format(message.author.display_name, self.leader_board[user.id]["rank"])
                    await self.bot.send_message(message.channel, msg)
                    fileIO("data/levels/leader_board.json", "save", self.leader_board)
            else:
                self.add_xp(id)
                self.gettingxp[id] = int(time.perf_counter())
                fileIO("data/levels/leader_board.json", "save", self.leader_board) 

def rate_limit(wait_length):
	last_time = 0
	
	def decorate(f):
		@wraps(f)
		def rate_limited(*args, **kwargs):
			nonlocal last_time
			diff = perf_counter() - last_time
			if diff < wait_length:
				sleep(wait_length - diff)
			
			r = f(*args, **kwargs)
			last_time = perf_counter()
			return r
		return rate_limited
	return decorate 

def eventuallyAny(coroFunc, *args, retryWait: float = 0.01,
                        timeout: float = 5):
    start = time.perf_counter()

    def remaining():
        return start + timeout - time.perf_counter()

    remain = remaining()
    data = None
    while remain >= 0:
        res = await coroFunc(*args)
        (complete, data) = res
        if complete:
            return data
        remain = remaining()
        if remain > 0:
            await asyncio.sleep(retryWait)
            remain = remaining()
    return data 

def put_load():
    port = genHa()[1]
    ha = HA('0.0.0.0', port)
    name = "hello"
    wallet = Wallet(name)
    wallet.addIdentifier(
        signer=DidSigner(seed=b'000000000000000000000000Steward1'))
    client = Client(name, ha=ha)
    with Looper(debug=getConfig().LOOPER_DEBUG) as looper:
        looper.add(client)
        print('Will send {} reqs in all'.format(numReqs))
        requests = sendRandomRequests(wallet, client, numReqs)
        start = perf_counter()
        for i in range(0, numReqs, numReqs // splits):
            print('Will wait for {} now'.format(numReqs // splits))
            s = perf_counter()
            reqs = requests[i:i + numReqs // splits + 1]
            waitForSufficientRepliesForRequests(looper, client, requests=reqs,
                                                customTimeoutPerReq=100,
                                                override_timeout_limit=True)
            print('>>> Got replies for {} requests << in {}'.
                  format(numReqs // splits, perf_counter() - s))
        end = perf_counter()
        print('>>>Total {} in {}<<<'.format(numReqs, end - start))
        exit(0) 

def simulate(self):
        """
        Do simulation for all enabled components.
        """
        timers = []
        for compID in self.componentsID:
            t1 = time.perf_counter()
            self.simulate_component(compID)
            t2 = time.perf_counter()
            timers.append((compID, t1, t2))

        logger.info("==================================================")
        logger.info(">>> Time usage <<<")
        logger.info("==================================================")
        for compID, t1, t2 in timers:
            logger.info("%s : %.1f [min]" % (compID, (t2-t1)/60))
        logger.info("--------------------------------------------------") 

def _task_test(self, **kwargs):
        """
        Test task ...
        """
        import time
        t1_start = time.perf_counter()
        t2_start = time.process_time()
        logger.info("Console TEST task: START ...")
        for i in range(kwargs["time"]):
            logger.info("Console TEST task: slept {0} seconds ...".format(i))
            time.sleep(1)
        logger.info("Console TEST task: DONE!")
        t1_stop = time.perf_counter()
        t2_stop = time.process_time()
        logger.info("Elapsed time: {0:.3f} (s)".format(t1_stop - t1_start))
        logger.info("CPU process time: {0:.3f} (s)".format(t2_stop - t2_start))
        return (True, None) 

def __call__(self, masker, dict_fact, cpu_time, io_time):
        test_time = time.perf_counter()
        if not hasattr(self, 'data'):
            self.data = masker.transform(self.test_imgs,
                                         confounds=self.test_confounds)
        scores = np.array([dict_fact.score(data) for data in self.data])
        len_imgs = np.array([data.shape[0] for data in self.data])
        score = np.sum(scores * len_imgs) / np.sum(len_imgs)
        self.test_time += time.perf_counter() - test_time
        this_time = time.perf_counter() - self.start_time - self.test_time
        self.score.append(score)
        self.time.append(this_time)
        self.cpu_time.append(cpu_time)
        self.io_time.append(io_time)
        self.iter.append(dict_fact.n_iter_)
        if self.info is not None:
            self.info['time'] = self.cpu_time
            self.info['score'] = self.score
            self.info['iter'] = self.iter 

def sync(self):
        """Synchronize data from library and actual data in the musics folder

        Raises:
            ValueError: When musics_folder is not set
        """
        if self.musics_folder is None or not pathlib.Path(self.musics_folder).is_dir():
            raise ValueError('Invalid music folder: ' + str(self.musics_folder))

        self.logger.info(f"Scanning {self.musics_folder}")
        start = time.perf_counter()
        self.__sync_songs()
        self.__sync_artists()
        self.__sync_albums()
        self.__sync_playlists()
        end = time.perf_counter()
        self.logger.info('Scan ended in {:.3f}'.format(end - start)) 

def __create_model(self):
        self.logger.info('Creating ListStore')
        start = time.perf_counter()

        model = AdapterSong.create_store()
        order = AbstractPlaylist.OrderBy[self.userconfig['grid']['sort']['field']]
        desc = self.userconfig['grid']['sort']['desc']
        songs = self.current_playlist.collections(order, desc)

        for row in songs:
            model.insert_with_valuesv(-1, AdapterSong.create_col_number(), AdapterSong.create_row(row))

        GObject.idle_add(lambda: self.__create_model_finished(model))

        end = time.perf_counter()
        self.logger.info('ListStore created in {:.3f} seconds'.format(end - start)) 

def ping(self, ctx):
        t1 = time.perf_counter()
        await ctx.trigger_typing()
        t2 = time.perf_counter()

        result = round((t2-t1)*1000)

        if int(result) >=200:
            em = discord.Embed(title="Ping : " + str(result) + "ms", description="... c'est quoi ce ping !", colour=0xFF1111)
            await ctx.send(embed=em)
        elif int(result) > 100 and int(result) < 200:
            em = discord.Embed(title="Ping : " + str(result) + "ms", description="Ca va, ça peut aller, mais j'ai l'impression d'avoir 40 ans !", colour=0xFFA500)
            await ctx.send(embed=em)
        elif int(result) <= 100:
            em = discord.Embed(title="Ping : " + str(result) + "ms", description="Wow c'te vitesse de réaction, je m'épate moi-même !",colour=0x11FF11)
            await ctx.send(embed=em)

    ##INFO## 

def ping(self, ctx):
        """Your average ping command."""
        # Set the embed for the pre-ping
        clock = random.randint(0x1F550, 0x1F567)  # pick a random clock
        embed = discord.Embed(colour=0xFFC107)
        embed.set_author(name=random.choice(PRE_PING_REMARKS), icon_url=emoji_url(chr(clock)))

        # Do the classic ping
        start = time.perf_counter()     # fuck time.monotonic()
        message = await ctx.send(embed=embed)
        end = time.perf_counter()       # fuck time.monotonic()
        ms = (end - start) * 1000

        # Edit the embed to show the actual ping
        embed.colour = 0x4CAF50
        embed.set_author(name='Poing!', icon_url=emoji_url('\U0001f3d3'))
        embed.add_field(name='Latency', value=f'{ctx.bot.latency * 1000 :.0f} ms')
        embed.add_field(name='Classic', value=f'{ms :.0f} ms', inline=False)

        await message.edit(embed=embed) 

def load_questions(self, msg):
        msg = msg.split(" ")
        if len(msg) == 2:
            _, qlist = msg
            if qlist == "random":
                chosen_list = randchoice(glob.glob("data/trivia/*.txt"))
                self.question_list = self.load_list(chosen_list)
                self.status = "new question"
                self.timeout = time.perf_counter()
                if self.question_list: await self.new_question()
            else:
                if os.path.isfile("data/trivia/" + qlist + ".txt"):
                    self.question_list = await self.load_list("data/trivia/" + qlist + ".txt")
                    self.status = "new question"
                    self.timeout = time.perf_counter()
                    if self.question_list: await self.new_question()
                else:
                    await trivia_manager.bot.say("There is no list with that name.")
                    await self.stop_trivia()
        else:
            await trivia_manager.bot.say("trivia [list name]") 

def check_answer(self, message):
        if message.author.id != trivia_manager.bot.user.id:
            self.timeout = time.perf_counter()
            if self.current_q is not None:
                for answer in self.current_q["ANSWERS"]:
                    if answer in message.content.lower():
                        self.current_q["ANSWERS"] = []
                        self.status = "correct answer"
                        self.add_point(message.author.name)
                        msg = "You got it {}! **+1** to you!".format(message.author.name)
                        try:
                            await trivia_manager.bot.send_typing(self.channel)
                            await trivia_manager.bot.send_message(message.channel, msg)
                        except:
                            await asyncio.sleep(0.5)
                            await trivia_manager.bot.send_message(message.channel, msg)
                        return True 

def game():
        # Controller page
	time_full = time.perf_counter()
	player_ip = request.remote_addr
        # To redirect players who isent in the ip list and has thearfor ni team
	redirect_var = True
	for i in players:
		if player_ip == i.ip:
			print("OK")
			redirect_var = False
	if redirect_var:
		return redirect(url_for('index'))
	team_var = get_team(player_ip)
	direction_var = None
	if request.method == 'POST':
                # Adds a request to move the robot in the multithread queue
		q.put(request.form['submit'])
	print(time.perf_counter() - time_full)
	return render_template('game.html',team=team_var, direction=direction_var) 

def test_get_clock_info(self):
        clocks = ['clock', 'perf_counter', 'process_time', 'time']
        if hasattr(time, 'monotonic'):
            clocks.append('monotonic')

        for name in clocks:
            info = time.get_clock_info(name)
            #self.assertIsInstance(info, dict)
            self.assertIsInstance(info.implementation, str)
            self.assertNotEqual(info.implementation, '')
            self.assertIsInstance(info.monotonic, bool)
            self.assertIsInstance(info.resolution, float)
            # 0.0 < resolution <= 1.0
            self.assertGreater(info.resolution, 0.0)
            self.assertLessEqual(info.resolution, 1.0)
            self.assertIsInstance(info.adjustable, bool)

        self.assertRaises(ValueError, time.get_clock_info, 'xxx') 

def write_pages(self, pages):
        sums = defaultdict(float)
        counts = defaultdict(int)

        # group by type
        by_type = defaultdict(list)
        for page in pages:
            by_type[(page.RENDER_PREFERRED_ORDER, page.TYPE)].append(page)

        # Render collecting timing statistics
        for (order, type), pgs in sorted(by_type.items(), key=lambda x:x[0][0]):
            start = time.perf_counter()
            for page in pgs:
                contents = page.render()
                for relpath, rendered in contents.items():
                    dst = self.output_abspath(relpath)
                    rendered.write(dst)
            end = time.perf_counter()
            sums[type] = end - start
            counts[type] = len(pgs)
        return sums, counts 

def launch(self):
        """Ask JupyterHub to launch the image."""
        await self.emit({
            'phase': 'launching',
            'message': 'Launching server...\n',
        })

        launcher = self.settings['launcher']
        username = launcher.username_from_repo(self.repo)
        try:
            launch_starttime = time.perf_counter()
            server_info = await launcher.launch(image=self.image_name, username=username)
            LAUNCH_TIME.labels(status='success').observe(time.perf_counter() - launch_starttime)
        except:
            LAUNCH_TIME.labels(status='failure').observe(time.perf_counter() - launch_starttime)
            raise
        event = {
            'phase': 'ready',
            'message': 'server running at %s\n' % server_info['url'],
        }
        event.update(server_info)
        await self.emit(event) 

def generate_output(args):
    if not args.test:
        args.test = glob_with_format(args.format) # by default
    tests = construct_relationship_of_files(args.test, args.format)
    for name, it in sorted(tests.items()):
        log.emit('')
        log.info('%s', name)
        if 'out' in it:
            log.info('output file already exists.')
            log.info('skipped.')
            continue
        with open(it['in']) as inf:
            begin = time.perf_counter()
            answer, proc = utils.exec_command(args.command, shell=args.shell, stdin=inf)
            end = time.perf_counter()
            log.status('time: %f sec', end - begin)
        if proc.returncode != 0:
            log.failure(log.red('RE') + ': return code %d', proc.returncode)
            log.info('skipped.')
            continue
        log.emit(log.bold(answer.decode().rstrip()))
        path = path_from_format(args.format, match_with_format(args.format, it['in']).groupdict()['name'], 'out')
        with open(path, 'w') as fh:
            fh.buffer.write(answer)
        log.success('saved to: %s', path) 

def _recorder(pid, stop, ival):
    """Subprocess call function to record cpu and memory."""
    t = t0 = time()

    process = psutil.Process(pid)

    if stop is None:
        while True:
            m = process.memory_info()
            print(psutil.cpu_percent(), ',', m[0], ',', m[1])
            sleep(ival)
            t = time()
    else:
        while t - t0 < stop:
            m = process.memory_info()
            print(psutil.cpu_percent(), ',', m[0], ',', m[1])
            sleep(ival)
            t = time() 

def fit(self, path=None):
        """Fit sub-learner"""
        if path is None:
            path = self.path
        t0 = time()
        transformers = self._load_preprocess(path)

        self._fit(transformers)

        if self.out_array is not None:
            self._predict(transformers, self.scorer is not None)

        o = IndexedEstimator(estimator=self.estimator,
                             name=self.name_index,
                             index=self.index,
                             in_index=self.in_index,
                             out_index=self.out_index,
                             data=self.data)

        save(path, self.name_index, o)

        if self.verbose:
            msg = "{:<30} {}".format(self.name_index, "done")
            f = "stdout" if self.verbose < 10 - 3 else "stderr"
            print_time(t0, msg, file=f) 

def _predict(self, transformers, score_preds):
        """Sub-routine to with sublearner"""
        n = self.in_array.shape[0]
        # For training, use ytemp to score predictions
        # During test time, ytemp is None
        xtemp, ytemp = slice_array(self.in_array, self.targets, self.out_index)
        t0 = time()

        if transformers:
            xtemp, ytemp = transformers.transform(xtemp, ytemp)
        predictions = getattr(self.estimator, self.attr)(xtemp)

        self.pred_time_ = time() - t0

        # Assign predictions to matrix
        assign_predictions(self.out_array, predictions,
                           self.out_index, self.output_columns, n)

        # Score predictions if applicable
        if score_preds:
            self.score_ = score_predictions(
                ytemp, predictions, self.scorer, self.name_index, self.name) 

def fit(self, path=None):
        """Fit transformers"""
        path = path if path else self.path
        t0 = time()
        xtemp, ytemp = slice_array(
            self.in_array, self.targets, self.in_index)

        t0_f = time()
        self.estimator.fit(xtemp, ytemp)
        self.transform_time_ = time() - t0_f

        if self.out_array is not None:
            self._transform()

        o = IndexedEstimator(estimator=self.estimator,
                             name=self.name_index,
                             index=self.index,
                             in_index=self.in_index,
                             out_index=self.out_index,
                             data=self.data)
        save(path, self.name_index, o)
        if self.verbose:
            f = "stdout" if self.verbose < 10 else "stderr"
            msg = "{:<30} {}".format(self.name_index, "done")
            print_time(t0, msg, file=f) 

def fit(self, path=None):
        """Evaluate sub-learner"""
        path = path if path else self.path
        if self.scorer is None:
            raise ValueError("Cannot generate CV-scores without a scorer")
        t0 = time()
        transformers = self._load_preprocess(path)
        self._fit(transformers)
        self._predict(transformers)

        o = IndexedEstimator(estimator=self.estimator,
                             name=self.name_index,
                             index=self.index,
                             in_index=self.in_index,
                             out_index=self.out_index,
                             data=self.data)
        save(path, self.name_index, o)

        if self.verbose:
            f = "stdout" if self.verbose else "stderr"
            msg = "{:<30} {}".format(self.name_index, "done")
            print_time(t0, msg, file=f) 

def _score_preds(self, transformers, index):
        # Train scores
        xtemp, ytemp = slice_array(self.in_array, self.targets, index)
        if transformers:
            xtemp, ytemp = transformers.transform(xtemp, ytemp)

        t0 = time()

        if self.error_score is not None:
            try:
                scores = self.scorer(self.estimator, xtemp, ytemp)
            except Exception as exc:  # pylint: disable=broad-except
                warnings.warn(
                    "Scoring failed. Setting error score %r."
                    "Details:\n%r" % (self.error_score, exc),
                    FitFailedWarning)
                scores = self.error_score
        else:
            scores = self.scorer(self.estimator, xtemp, ytemp)
        pred_time = time() - t0

        return scores, pred_time 

def answer_with_doc(self, question: str, doc: str) -> Tuple[np.ndarray, List[WebParagraph]]:
        """ Answer a question using the given text as a document """

        self.log.info("Answering question \"%s\" with a given document" % question)
        # Tokenize
        question = self.tokenizer.tokenize_paragraph_flat(question)
        context = [self.tokenizer.tokenize_with_inverse(x, False) for x in self._split_regex.split(doc)]

        # Split into super-paragraphs
        context = self._split_document(context, "User", None)

        # Select top paragraphs
        context = self.paragraph_selector.prune(question, context)
        if len(context) == 0:
            raise ValueError("Unable to process documents")

        # Select the top answer span
        t0 = time.perf_counter()
        span_scores = self._get_span_scores(question, context)
        self.log.info("Computing answer spans took %.5f seconds" % (time.perf_counter() - t0))
        return span_scores 

def loadQuestions(self, msg):
		msg = msg.split(" ")
		if len(msg) == 2:
			_, qlist = msg
			if qlist == "random":
				chosenList = choice(glob.glob("trivia/*.txt"))
				self.questionList = self.loadList(chosenList)
				self.status = "new question"
				self.timeout = time.perf_counter()
				if self.questionList: await self.newQuestion()
			else:
				if os.path.isfile("trivia/" + qlist + ".txt"):
					self.questionList = self.loadList("trivia/" + qlist + ".txt")
					self.status = "new question"
					self.timeout = time.perf_counter()
					if self.questionList: await self.newQuestion()
				else:
					await client.send_message(self.channel, "`There is no list with that name.`")
					await self.stopTrivia()
		else:
			await client.send_message(self.channel, "`" + settings["PREFIX"] + "trivia [list name]`") 

def isChallengeOngoing(message): #Work in progress
	global anagram_sessions, anagram_sessions_timestamps
	id = message.channel.id
	for session in anagram_sessions:
		if time.perf_counter() - session.started >= 600:
			if session.done:
				anagram_sessions.remove(session)
				anagram_sessions.append(Anagram(message))
				return True
			else:
				await client.send_message(message.channel, "{} `A challenge is already ongoing.`".format(message.author.mention))
				return True
		else:
			await client.send_message(message.channel, "{} `You have to wait 10 minutes before each challenge.`".format(message.author.mention))
			return True
	anagram_sessions.append(Anagram(message))