Python time.perf_counter() Examples

The following are code examples for showing how to use time.perf_counter(). They are extracted from open source Python projects. You can vote up the examples you like or vote down the exmaples you don't like. You can also save this page to your account.

Example 1
Project: fg21sim   Author: liweitianux   File: foregrounds.py    (license) View Source Project 14 votes vote down vote up
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("--------------------------------------------------") 
Example 2
Project: Jumper-Cogs   Author: Redjumpman   File: cookie.py    (GNU General Public License v3.0) View Source Project 6 votes vote down vote up
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 
Example 3
Project: Jumper-Cogs   Author: Redjumpman   File: shop.py    (GNU General Public License v3.0) View Source Project 6 votes vote down vote up
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 
Example 4
Project: Jumper-Cogs   Author: Redjumpman   File: heist.py    (GNU General Public License v3.0) View Source Project 6 votes vote down vote up
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) 
Example 5
Project: Jumper-Cogs   Author: Redjumpman   File: heist.py    (GNU General Public License v3.0) View Source Project 6 votes vote down vote up
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 
Example 6
Project: DenoiseAverage   Author: Pella86   File: LogTimes.py    (license) View Source Project 6 votes vote down vote up
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=============================================================") 
Example 7
Project: mobot   Author: JokerQyou   File: messagequeue.py    (license) View Source Project 6 votes vote down vote up
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) 
Example 8
Project: mistletoe   Author: miyuchina   File: benchmark.py    (license) View Source Project 6 votes vote down vote up
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 
Example 9
Project: cpsc415   Author: WheezePuppet   File: chess_headless.py    (license) View Source Project 6 votes vote down vote up
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) 
Example 10
Project: cpsc415   Author: WheezePuppet   File: chess_view.py    (license) View Source Project 6 votes vote down vote up
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() 
Example 11
Project: hivemind   Author: steemit   File: methods.py    (license) View Source Project 6 votes vote down vote up
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 
Example 12
Project: hivemind   Author: steemit   File: steem_client.py    (license) View Source Project 6 votes vote down vote up
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) 
Example 13
Project: hivemind   Author: steemit   File: steem_client.py    (license) View Source Project 6 votes vote down vote up
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 
Example 14
Project: hivemind   Author: steemit   File: accounts.py    (license) View Source Project 6 votes vote down vote up
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))) 
Example 15
Project: hivemind   Author: steemit   File: accounts.py    (license) View Source Project 6 votes vote down vote up
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)) 
Example 16
Project: wdom   Author: miyakogi   File: base.py    (license) View Source Project 6 votes vote down vote up
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)) 
Example 17
Project: hurt   Author: io-digital   File: tolerance3.py    (license) View Source Project 6 votes vote down vote up
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} 
Example 18
Project: device-updater   Author: spark   File: devices.py    (license) View Source Project 6 votes vote down vote up
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 
Example 19
Project: sbds   Author: steemit   File: populate.py    (license) View Source Project 6 votes vote down vote up
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) 
Example 20
Project: pyrealtime   Author: ewhitmire   File: layer.py    (license) View Source Project 6 votes vote down vote up
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() 
Example 21
Project: sdos-core   Author: sdos   File: PerfTest.py    (license) View Source Project 6 votes vote down vote up
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))) 
Example 22
Project: sdos-core   Author: sdos   File: PerfTest.py    (license) View Source Project 6 votes vote down vote up
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))) 
Example 23
Project: sdos-core   Author: sdos   File: PerfTest.py    (license) View Source Project 6 votes vote down vote up
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)))



###############################################################################
############################################################################### 
Example 24
Project: ridings-cogs   Author: ridinginstyle00   File: Levels.py    (license) View Source Project 6 votes vote down vote up
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) 
Example 25
Project: holo   Author: TheEnigmaBlade   File: __init__.py    (license) View Source Project 6 votes vote down vote up
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 
Example 26
Project: indy-node   Author: hyperledger   File: load_test.py    (license) View Source Project 6 votes vote down vote up
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 
Example 27
Project: indy-node   Author: hyperledger   File: load.py    (license) View Source Project 6 votes vote down vote up
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) 
Example 28
Project: fg21sim   Author: liweitianux   File: foregrounds.py    (license) View Source Project 6 votes vote down vote up
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("--------------------------------------------------") 
Example 29
Project: fg21sim   Author: liweitianux   File: console.py    (license) View Source Project 6 votes vote down vote up
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) 
Example 30
Project: modl   Author: arthurmensch   File: fmri.py    (license) View Source Project 6 votes vote down vote up
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 
Example 31
Project: MokaPlayer   Author: vedard   File: library.py    (license) View Source Project 6 votes vote down vote up
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)) 
Example 32
Project: MokaPlayer   Author: vedard   File: main_window.py    (license) View Source Project 6 votes vote down vote up
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)) 
Example 33
Project: tuxbot-bot   Author: outout14   File: basics.py    (license) View Source Project 6 votes vote down vote up
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## 
Example 34
Project: Chiaki-Nanami   Author: Ikusaba-san   File: otherstuff.py    (license) View Source Project 6 votes vote down vote up
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) 
Example 35
Project: Shallus-Bot   Author: cgropp   File: trivia.py    (license) View Source Project 6 votes vote down vote up
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]") 
Example 36
Project: Shallus-Bot   Author: cgropp   File: trivia.py    (license) View Source Project 6 votes vote down vote up
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 
Example 37
Project: mindstorm_game   Author: Hackslashloot   File: flask_server.py    (license) View Source Project 6 votes vote down vote up
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) 
Example 38
Project: web_ctp   Author: molebot   File: test_time.py    (license) View Source Project 6 votes vote down vote up
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') 
Example 39
Project: staticsite   Author: spanezz   File: build.py    (license) View Source Project 6 votes vote down vote up
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 
Example 40
Project: binderhub   Author: jupyterhub   File: builder.py    (license) View Source Project 6 votes vote down vote up
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) 
Example 41
Project: online-judge-tools   Author: kmyk   File: test.py    (license) View Source Project 6 votes vote down vote up
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) 
Example 42
Project: mlens   Author: flennerhag   File: utils.py    (license) View Source Project 6 votes vote down vote up
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() 
Example 43
Project: mlens   Author: flennerhag   File: learner.py    (license) View Source Project 6 votes vote down vote up
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) 
Example 44
Project: mlens   Author: flennerhag   File: learner.py    (license) View Source Project 6 votes vote down vote up
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) 
Example 45
Project: mlens   Author: flennerhag   File: learner.py    (license) View Source Project 6 votes vote down vote up
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) 
Example 46
Project: mlens   Author: flennerhag   File: learner.py    (license) View Source Project 6 votes vote down vote up
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) 
Example 47
Project: mlens   Author: flennerhag   File: learner.py    (license) View Source Project 6 votes vote down vote up
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 
Example 48
Project: document-qa   Author: allenai   File: qa_system.py    (license) View Source Project 6 votes vote down vote up
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 
Example 49
Project: HAL-9000   Author: AnsonRS   File: hal.py    (license) View Source Project 6 votes vote down vote up
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]`") 
Example 50
Project: HAL-9000   Author: AnsonRS   File: economy.py    (license) View Source Project 6 votes vote down vote up
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))