def __init__(self, context): self._context = context self._writer = Writer(context.tag) self._prepare = Prepare(context) self._event = Event(context) self._postprocessing = PostProcessing(context, self._writer) self._system_monitor = Sysmon( self._context.args.tick_duration, self._context.args.amount_of_ticks, )
class Runner: """ Prepare and execute the simulation and post process the data""" def __init__(self, context): self._context = context self._writer = Writer(context.tag) self._prepare = Prepare(context) self._event = Event(context) self._postprocessing = PostProcessing(context, self._writer) self._system_monitor = Sysmon( self._context.args.tick_duration, self._context.args.amount_of_ticks, ) def run(self): try: self._prepare.create_folder() StepTimes().add( 'preparation_start' ) # TODO writes to old directory because does not exist yet Info().status = "preperation_start" self._prepare.execute() logging.info('End of Preparation') #StepTimes().add('preparation_start') StepTimes().add('simulation_start') logging.info('Start of simulation') self._system_monitor.start() self._event.execute( timeout=25) # TODO check if timeout works as expected self._system_monitor.exit() logging.info('End of simulation') StepTimes().add('postprocessing_start') self._postprocessing.execute() StepTimes().add('postprocessing_end') except Exception as exce: Info().status = f"failed with {exce}" self._postprocessing.clean_up_docker_safe() raise exce
def _build(self, ai): print '========== Found AI to be build: <', ai['user'].encode('utf-8'), ',', ai['idOfUser'], '>, upload date: ', ai['uploadDate'] p = Prepare(ai).Run() ID = str(ai['_id']) if p['status'] == 'failure': status = 'Unavailable' info = p['error'] else: status = 'Available' info = p['info'] self._uploadAI(ID, status, info, path.join(const.AI_SAVE_DIRECTORY, 'ai_' + ID)) print ' Done!'
def move(): winner_player = Prepare.verify_rule() next_player, hand, palette = Prepare.next_player(Helper.players, winner_player) if winner_player != next_player: print('Następny jest gracz ' + str(next_player)) print("Na ręce:") print(hand) print("W palecie") print(palette) option = input("Co zagrywasz? \n" "1. Kartę na tło \n" "2. Kartę na paletę \n" "3. Kartę na paletę i tło \n" "4. Poddaje się \n") if option == "1": result = Prepare.add_card(hand, palette, False, False) elif option == "2": result = Prepare.add_card(hand, palette, True, False) elif option == "3": result = Prepare.add_card(hand, palette, True, True) elif option == "4": print("Przegrałeś") result = False else: print("Wrong number") result = False if result: move() else: print("Nadal przegrywasz") else: print("Nadal przegrywasz")
def hello(): print("Witajcie w Red7 \n ************") players = input("Proszę podać ilu będzie graczy ") players = int(players) Helper.players = players # if 4 >= int(players) >= 2: # player1 = input("Podaj imię pierwszego gracza: ") # player2 = input("Podaj imię drugiego gracza: ") # # if int(players) == 3: # player3 = input("Podaj imię trzeciego gracza: ") # elif int(players) == 4: # player3 = input("Podaj imię trzeciego gracza: ") # player4 = input("Podaj imię czwartego gracza: ") if Prepare.generate_start_cards(players): move()
def run(unknown_arguments=False): for file in [config.ticks_csv, config.network_csv, config.nodes_csv]: utils.check_for_file(file) parser = _create_parser() if unknown_arguments: args = parser.parse_known_args(sys.argv[2:])[0] else: args = parser.parse_args(sys.argv[2:]) logging.info("Parsed arguments in {}: {}".format(__name__, args)) utils.update_args(args) _check_skip_ticks(args.skip_ticks) context = Context() logging.info(config.log_line_run_start + context.run_name) tag = context.args.tag if hasattr(context.args, 'tag_appendix'): tag += context.args.tag_appendix writer = Writer(tag) runner = Runner(context, writer) prepare = Prepare(context) runner._prepare = prepare postprocessing = PostProcessing(context, writer) runner._postprocessing = postprocessing event = Event(context) runner._event = event start = time.time() runner.run() logging.info("The duration of the run was {} seconds".format( str(time.time() - start)))
def setUp(self): self.context = Mock() self.prepare = Prepare(self.context) bitcoin.SelectParams('regtest')
class TestPrepare(TestCase): def setUp(self): self.context = Mock() self.prepare = Prepare(self.context) bitcoin.SelectParams('regtest') @patch('node.wait_until_height_reached', lambda node, height: None) @patch('utils.sleep', lambda time: None) @patch('prepare._calc_number_of_tx_chains', lambda txs_per_tick, block_per_tick, amount_of_nodes: 5) def test_warmup_block_generation(self): node_0 = MagicMock() node_1 = MagicMock() nodes = [node_0, node_1] self.context.nodes.values.return_value = nodes self.prepare._pool = MagicMock() self.prepare._give_nodes_spendable_coins() self.assertEqual(node_0.execute_rpc.call_count, 2) self.assertEqual(node_1.execute_rpc.call_count, 2) @patch('os.path.exists') @patch('os.path.islink') @patch('os.makedirs') @patch('bash.check_output') @patch('builtins.open', new_callable=mock_open) def test_prepare_simulation_dir(self, m_open, m_check_output, m_makedirs, m_islink, m_exists): m_exists.return_value = False self.prepare._pool = MagicMock() self.prepare._prepare_simulation_dir() self.assertEqual(m_makedirs.call_count, 3) self.assertEqual(m_check_output.call_count, 10) @patch('bash.check_output') def test_remove_old_containers_if_exists(self, m_check_output): m_check_output.return_value = ['container1', 'container2'] prepare._remove_old_containers_if_exists() self.assertEqual(m_check_output.call_count, 2) @patch('bash.check_output') def test_remove_old_containers_if_exists_no_old_containers( self, m_check_output): m_check_output.return_value = [] prepare._remove_old_containers_if_exists() self.assertEqual(m_check_output.call_count, 1) @patch('utils.sleep', lambda t: None) @patch('bash.call_silent') @patch('bash.check_output') def test_recreate_network(self, m_check_output, m_call_silent): m_call_silent.return_value = 0 prepare._recreate_network() self.assertEqual(m_check_output.call_count, 2) self.assertEqual(m_call_silent.call_count, 1) @patch('utils.sleep', lambda t: None) @patch('bash.call_silent') @patch('bash.check_output') def test_recreate_network_no_network(self, m_check_output, m_call_silent): m_call_silent.return_value = -1 prepare._recreate_network() self.assertEqual(m_check_output.call_count, 1) def test_calc_number_of_tx_chains(self): config.max_in_mempool_ancestors = 25 amount = prepare._calc_number_of_tx_chains(2, 1 / 600, 10) self.assertEqual(amount, 51)
def sendPrepare(): global bNum bNum = BallotNum(bNum.getDepth(), bNum.getSeqNum() + 1, bNum.getPid()) prepMsg = Prepare('prepare', bNum, MY_PORT) print("Sending prepare messages.") broadcastMsg(pickle.dumps(prepMsg))
def gwas(start_snp, end_snp, individuals, ants_number, update_times, factor, threshold): """ individuals: sum of cases and control. factor: 0<factor<1 user-adjustable distribution.if factor is near 1,snps with high scores are only slightly more likely to be selected. threshold <-> P-Value: 26.12<->0.001;20.09<->0.01;15.51<->.0.05 """ snps_number = end_snp - start_snp + 1 dict_pair = Prepare.dict_pair(start_snp, end_snp) print('dict_pair done') n = 0 for order in range(1, 101): dict_prob = Prepare.dict_prob1(start_snp, end_snp + 1) print('dict_prob done') label, data_set = Prepare.data_matrix(order, individuals, snps_number) dict_weka = Prepare.load_weka_ranking(order) snps_sequence = Prepare.snps_sequence1(start_snp, end_snp) snps_scores = [0] * snps_number # Rank dict on weight,return a list of tuples list_weka = sorted(dict_weka.items(), key=lambda weka: weka[1], reverse=True) rank = Prepare.scaling_rank(factor, snps_number) for snp_weight_tuple, new_weight in zip(list_weka, rank): # allocate scaling rank weight to corresponding snp snps_scores[snp_weight_tuple[0] - start_snp] = new_weight selected_pairs = {} for x in range(update_times): list_k1_threshold = [] # 存储chi2_statistics > 阈值的pair在dict_prob[first_snp]中的索引位置 list_k2_threshold = [] # 存储chi2_statistics > 阈值的pair在dict_prob[second_snp]中的索引位置 list_chi2_statistics = [] # 存储chi2_statistics > 阈值的pair的卡方值,在update的时候使用 list_k1 = [] # 存储chi2_statistics < 阈值的pair在dict_prob[first_snp]中的索引位置 list_k2 = [] # 存储chi2_statistics < 阈值的pair在dict_prob[second_snp]中的索引位置 list_first_snp_threshold = [] # 存储chi2_statistics > 阈值的first_snp list_second_snp_threshold = [] # 存储chi2_statistics > 阈值的second_snp list_first_snp = [] # 存储chi2_statistics < 阈值的first_snp list_second_snp = [] # 存储chi2_statistics < 阈值的second_snp for y in range(ants_number): first_snp = Ant.ant_first_snp(snps_sequence, snps_scores) second_snp = Ant.ant_second_snp(first_snp, dict_pair, dict_prob) # print(first_snp, second_snp) if second_snp > first_snp: k1 = second_snp - start_snp - 1 k2 = first_snp - start_snp else: k1 = second_snp - start_snp k2 = first_snp - start_snp - 1 case_row, control_row = ChiSquareTest.chi2_table(data_set, label, first_snp, second_snp, individuals) sum_colum, A2_NcNr, chi2_statistics = ChiSquareTest.chi2_test(case_row, control_row, individuals) if chi2_statistics > threshold: list_k1_threshold.append(k1) list_k2_threshold.append(k2) list_chi2_statistics.append(chi2_statistics) list_first_snp_threshold.append(first_snp) list_second_snp_threshold.append(second_snp) else: list_k1.append(k1) list_k2.append(k2) list_first_snp.append(first_snp) list_second_snp.append(second_snp) # 更新条件概率和snps_scores. # 除以 10 的目的是将卡方值转换到和weight同样的量级.snps_score_original[x]引入expert information for m, i, j in zip(list_first_snp_threshold, list_k1_threshold, list_chi2_statistics): dict_prob[m][i] += (int(j) / 10) for m, i, j in zip(list_second_snp_threshold, list_k2_threshold, list_chi2_statistics): dict_prob[m][i] += (int(j) / 10) for m, i in zip(list_first_snp, list_k1): dict_prob[m][i] = 0 for m, i in zip(list_second_snp, list_k2): dict_prob[m][i] = 0 for first, second, i in zip(list_first_snp_threshold, list_second_snp_threshold, list_k1_threshold): selected_pairs[(first, second)] = dict_prob[first][i] print(selected_pairs) result = sorted(selected_pairs.items(), key=lambda x: x[1], reverse=True) for x in result[0:20]: if x[0] == (999, 988) or x[0] == (998, 999): n += 1 break f = open('result_conProb-H0.1-{ants}_{updates}-fac={factor}.txt'.format( ants=ants_number, updates=update_times, factor=factor), 'a') f.writelines('\n') f.writelines(str(x[0]) + '\t' + str(x[1]) + '\n' for x in result[0:20]) f.writelines('----------------------------------') f.close() f = open('result_conProb-H0.1-{ants}_{updates}-fac={factor}.txt'.format( ants=ants_number, updates=update_times, factor=factor), 'a') f.writelines('\nThe pow of this ACO algorithm is ' + str(n) + '%') f.close()