def command_Eat(self): # command 30
eatCoord = self.getAdjCoordByDirection(self.faceDirection)
eatCoord = (Helpers.loopValue(eatCoord[0], 0,
Logic.gameWorld.worldSizeInCells[0] - 1),
eatCoord[1])
if Logic.gameWorld.whatIsOnTile(eatCoord) == World.WorldObject.Bot:
attackForce = int(self.getNextGenomeByte() / 2)
totalFood = Logic.attackBot(eatCoord,
attackForce) # атакуем то, что впереди
foodToHealth = int(totalFood * Config.FOOD_TO_HEALTH)
self.health += foodToHealth
foodToEnergy = int(totalFood * Config.FOOD_TO_ENERGY)
self.energy += foodToEnergy
self.writeToLog("Eat bot at {0}! Gained H/E: {1}/{2}".format(
eatCoord, foodToHealth, foodToEnergy))
self.commandPointer += 2
self.executeNextCommand = False
self.adjustColor("Red")
elif Logic.gameWorld.whatIsOnTile(
eatCoord) == World.WorldObject.Organic:
totalFood = Logic.removeOrganic(
Logic.gameWorld.getObjectFromTile(eatCoord))
foodToHealth = int(totalFood * Config.ORGANIC_TO_HEALTH)
self.health += foodToHealth
foodToEnergy = int(totalFood * Config.ORGANIC_TO_ENERGY)
self.energy += foodToEnergy
self.writeToLog("Eat organic at {0}! Gained H/E: {1}/{2}".format(
eatCoord, foodToHealth, foodToEnergy))
self.commandPointer += 3
self.adjustColor("Red")
else:
self.writeToLog("Nothing to be eated!")
self.commandPointer += 1
self.executeNextCommand = False
def command_Multiply(self): # command 15
multiplyIsDone = False
for direction in range(1, 8):
coord = self.getAdjCoordByDirection(
self.getLoopedValue(8, self.faceDirection + direction))
coord = (Helpers.loopValue(coord[0], 0,
Logic.gameWorld.worldSizeInCells[0] -
1), coord[1])
nearbyObject = Logic.gameWorld.whatIsOnTile(coord)
if nearbyObject == World.WorldObject.Empty:
self.writeToLog("Making child bot at {0}".format(coord))
Logic.newBot(coord, botParent=self)
self.commandPointer += 1
multiplyIsDone = True
self.executeNextCommand = False
self.health = int(self.health / 2.25)
self.energy = int(self.energy / 2.25)
break
if multiplyIsDone is False:
self.writeToLog("Tryed to make a child bot but there's no room!")
if Config.DIE_IF_NO_ROOM is True:
self.health = 0
else:
self.commandPointer += 2
self.executeNextCommand = False
def SendTablesToLogic(initial_table, goal_table):
print()
print("Tablas recibidas")
initial_table.PrintTorreDetallada()
goal_table.PrintTorreDetallada()
Logic.RecibirInformacionDesdeInterfaz(initial_table, goal_table)
return Logic.GetSolution()
def game_over_check(board):
global winner
#Check for pieces vertically for 4 in a row
vertical = Logic.vertical_check(board)
if vertical != 'None':
winner = vertical
return True
#Check for pieces horizontally
horizontal = Logic.horizontal_check(board)
if horizontal != 'None':
winner = horizontal
return True
#Check for pieces diagonally
diagonal = Logic.diagonal_check(board)
if diagonal != 'None':
winner = diagonal
return True
#Checks if its a draw
draw = Logic.draw_check(board)
if draw != 'None':
winner = 'Nobody'
return True
def ativabotoes(botoes_jogo, errados, alterados, jogo, mat, strart_time, times,
n_select, linha, coluna, ecra, tempo, best_results,
dificuldade):
result = False
if botoes_jogo[0]:
errados = Logic.constroi_errados(alterados, jogo, mat)
strart_time = time.time()
botoes_jogo[0] = False
else:
actual_time = time.time() - strart_time
if actual_time >= times:
errados = []
if botoes_jogo[1]:
jogo = Logic.copia_matriz(mat)
botoes_jogo[1] = False
if botoes_jogo[2] and n_select:
jogo[linha][coluna] = mat[linha][coluna]
botoes_jogo[2] = False
if botoes_jogo[3]:
ecra = 5
tempo = time.time() - tempo
result = Print.correto(jogo)
if result:
Results.adiciona_lista(tempo, dificuldade, best_results)
Results.gravar_resultados(best_results)
botoes_jogo[3] = False
return errados, strart_time, jogo, ecra, tempo, best_results, result
def __init__(self):
self.data = 0x00
self.address = 0x0000
self.dataspace = 2 ** 8
self.address_space = 2 ** 16
# Registers
self.accumulator = Logic.register(8)
self.bc = [Logic.register(8),Logic.register(8)]
def fileChoice(self):
fileName, filetype = QFileDialog.getOpenFileName(
self, "选取文件", None,
"JPEG Files (*.jpg);;PixMap Files (*.png)") # 设置文件扩展名过滤,注意用双分号间隔
print(fileName)
try:
self.static = Logic(fileName)
self.fileFlag = 1
except Exception:
print('未选择')
def endStateCheck(node, nextMove):
whiteCheckmate = Logic.is_checkmate(node.state, P.WHITE)
blackCheckmate = Logic.is_checkmate(node.state, P.BLACK)
if (whiteCheckmate or blackCheckmate):
node.setWeight()
if ((whiteCheckmate and node.color == P.BLACK) or (blackCheckmate and node.color == P.WHITE)):
return (100000 * (node.depthLim+1)) / (node.depth + 1), nextMove
return (-100000 * (node.depthLim+1)) / (node.depth + 1), nextMove
elif (whiteCheckmate == None or blackCheckmate == None):
return 0, nextMove
raise AI_Exception(node.state, "Node has no next moves despite not being in an ending state", node.color)
def main(_args):
tt = _create_truthtable(_args.n_vars[0], _args.truth_table[0])
initial_state = Logic.State(GATES, tt, _args.n_vars[0], gate_limit=_args.u_gate_lim[0],
gate_l_limit=_args.l_gate_lim[0], height_limit=_args.height_lim[0])
problem = Logic.Problem(initial_state)
solution = Search.simulated_annealing(problem, Search.exp_schedule(_args.k[0], _args.lam[0], _args.limit[0]))
print("\nSolution found with simulated annealing:", solution.state)
X = exprvars('x', _args.n_vars[0])
f = truthtable(X, _args.truth_table[0])
print("Product of sums form", truthtable2expr(f).to_cnf())
print("Sum of products form", truthtable2expr(f).to_dnf())
def correto(jogo):
if Logic.jogo_acabou(jogo):
lista = ["Victory",
"easy peasy lemon squeezy",
"Easy win"]
return Logic.chose_one(lista)
else:
lista = ["Defeat",
"Noob ...",
"Wtf, are you on drugs ?",
"Wtf, you dumb ?"]
return Logic.chose_one(lista)
def __init__(self, window):
"""The Obvious"""
super(Game, self).__init__()
self.window = window
self.makeshitgo = True
self.turn = 1
self.num_players = 1
"""Makes ports and players"""
self.ports = Logic.instance_ports(Config.list_ports)
self.players = Logic.initiate_players(self.num_players,
self.ports, window)
self.npc = [Logic.Player("Galleon",
Logic.Port("Bermuda"), "Blackbeard")]
window.InfoBar.show()
def keydownevent(self, c, x, y):
#print ("*******************************************************************************")
try:
self.keys[c] = True
if self.joystick.callback_down is not None:
self.joystick.callback_down(c)
#print(self.keys)
if self.joystick.isFire(self.keys):
Logic.event(self.keys, c, self.solomon)
except Exception as e:
print(e)
pass
glutPostRedisplay()
def group_by_chromosome(self, data_dict, deli_str, ignore_chrm_list):
logic = Logic.Logics()
result_dict = {}
aqia_dict = {}
for trnscrpt_id, vals_arr in data_dict.items():
dscript = vals_arr[0]
chrsm = dscript[dscript.index(deli_str) + len(deli_str):].split(":")[0]
if logic.filter_out_by_chrm(chrsm, ignore_chrm_list):
continue
if 'AQIA' in chrsm:
if chrsm in aqia_dict:
if trnscrpt_id not in aqia_dict[chrsm]:
aqia_dict[chrsm].update({trnscrpt_id: vals_arr})
else:
aqia_dict.update({chrsm: {trnscrpt_id: vals_arr}})
continue
if chrsm in result_dict:
if trnscrpt_id not in result_dict[chrsm]:
result_dict[chrsm].update({trnscrpt_id: vals_arr})
else:
result_dict.update({chrsm: {trnscrpt_id: vals_arr}})
return result_dict, aqia_dict
def get_target_seq(self, path, init_arr):
logic = Logic.Logics()
tmp_dict = {}
pam_seq = init_arr[0]
add_seq1_len = init_arr[1]
spacer_len = init_arr[2]
add_seq2_len = init_arr[3]
pam_len = len(pam_seq)
std_tot_len = add_seq1_len + spacer_len + pam_len + add_seq2_len
for seq_record in SeqIO.parse(path, "fasta"):
trncrpt_id = seq_record.id
if trncrpt_id not in tmp_dict:
tmp_dict.update({trncrpt_id: [seq_record.description]})
tmp_p_str = ""
for c in seq_record.seq:
tmp_p_str = tmp_p_str + c.upper()
if len(tmp_p_str) > std_tot_len:
tmp_p_str = tmp_p_str[-std_tot_len:]
if len(tmp_p_str) == std_tot_len:
if 'N' not in tmp_p_str:
if logic.match(0, tmp_p_str[-(add_seq2_len + pam_len):-add_seq2_len], pam_seq):
tmp_dict[trncrpt_id].append(tmp_p_str)
return tmp_dict
def create_game(sprite_size, is_new):
# Здесь создаются глобальные переменные
global hero, engine, drawer, iteration
# Если создается новая игра
if is_new:
# Герой игры
hero = Objects.Hero(base_stats, Service.create_sprite(
os.path.join("texture", "Hero.png"), sprite_size))
# Движок игры
engine = Logic.GameEngine()
# Инициализация игры
Service.service_init(sprite_size)
# Перезагрузка игры, происходит при запуске и смене уровня
Service.reload_game(engine, hero)
drawer = SE.GameSurface((640, 480), pygame.SRCALPHA, (0, 480),
SE.ProgressBar((640, 120), (640, 0),
SE.InfoWindow((160, 600), (50, 50),
SE.HelpWindow((700, 500), pygame.SRCALPHA, (0, 0),
SE.ScreenHandle((0, 0))))))
else:
engine.sprite_size = sprite_size
hero.sprite = Service.create_sprite(
os.path.join("texture", "Hero.png"), sprite_size)
Service.service_init(sprite_size, False)
engine.sprite_size = sprite_size
# В метод передается игровой движок
drawer.connect_engine(engine)
iteration = 0
def command_GrowOrgan(self): # command 35
organGrowIsDone = False
organGenome = [0] * self.organGenomeSize
for i in range(self.organGenomeSize):
organGenome[i] = self.genome[self.getLoopedValue(
self.genomeSize, self.commandPointer + 1 + i)]
for direction in range(1, 7):
coord = self.getAdjCoordByDirection(
self.getLoopedValue(8, self.faceDirection + direction))
coord = (Helpers.loopValue(coord[0], 0,
Logic.gameWorld.worldSizeInCells[0] -
1), coord[1])
nearbyObject = Logic.gameWorld.whatIsOnTile(coord)
if nearbyObject == World.WorldObject.Empty:
self.writeToLog("Making organ at {0}".format(coord))
self.organs.append(Logic.newOrgan(coord, self, organGenome))
self.commandPointer += 1
organGrowIsDone = True
self.executeNextCommand = False
self.health = int(self.health / 2.25)
self.energy = int(self.energy / 2.25)
break
if organGrowIsDone is False:
self.writeToLog("Tryed to grow organ but there's no room!")
if Config.DIE_IF_NO_ROOM is True:
self.health = 0
else:
self.commandPointer += 2
self.executeNextCommand = False
def command_CheckIfRelative(self): # command 16
nextByte = self.getNextGenomeByte(
) # смотрим, какой байт следующий в геноме
# вычисляем значение относительного поворота
lookValue = nextByte % 8
# вычисляем направление в зависимости от того, куда повёрнут бот
directionToCheck = self.getLoopedValue(8,
self.faceDirection + lookValue)
# смотрим, что там находится
coord = self.getAdjCoordByDirection(directionToCheck)
coord = (Helpers.loopValue(coord[0], 0,
Logic.gameWorld.worldSizeInCells[0] - 1),
coord[1])
nearbyObject = Logic.gameWorld.whatIsOnTile(coord)
if nearbyObject == World.WorldObject.Bot:
anotherBot = Logic.gameWorld.getObjectFromTile(coord)
if Logic.compareGenome(self, anotherBot) is True:
self.writeToLog("There is a relative at {0}!".format(coord))
self.commandPointer += self.genome[self.getLoopedValue(
self.genomeSize, self.commandPointer + 2)]
self.executeNextCommand = True
else:
self.writeToLog("There is a stranger at {0}!".format(coord))
self.commandPointer += self.genome[self.getLoopedValue(
self.genomeSize, self.commandPointer + 3)]
self.executeNextCommand = True
def anlyze_indel_by_MAIN_to_SUB():
util = Util.Utils()
logic_prep = LogicPrep.LogicPreps()
logic = Logic.Logics()
brcd_list = util.csv_to_list_ignr_header(WORK_DIR + INPUT + BRCD_FILE)
brcd_arr = logic_prep.make_arr_list_to_list(brcd_list)
trgt_list = []
trgt_err_list = []
for path in [MAIN_DIR, SUB_DIR]:
csv_list = util.csv_to_list_ignr_header(
WORK_DIR + INPUT + path + F_TABLE_FILE, "\t")
result_list, err_list = logic_prep.get_data_by_cell_id(
csv_list, brcd_arr, CONST_INIT)
trgt_list.append(result_list)
trgt_err_list.append(err_list)
# result_dict = logic.count_len_arr_mut_non_mut_by_main_list(trgt_list[0], trgt_list[1], brcd_arr)
result_dict = logic.count_cell_mut_non_mut_by_main_list(
trgt_list[0], trgt_list[1])
util.make_excel_indel_frequency_by_cell_id(
WORK_DIR + "output/result_indel_" + MAIN_SUB_NAME[0] + "_" +
MAIN_SUB_NAME[1], result_dict, MAIN_SUB_NAME)
for idx in range(len(trgt_err_list)):
sorted_err_list = logic_prep.sort_list_by_ele(trgt_err_list[idx], -1)
logic.count_num_by_err(sorted_err_list)
util.make_excel_err_list(
WORK_DIR + "output/" + MAIN_SUB_NAME[idx] + "_error_list",
sorted_err_list)
def get_pairwise2_needle_dict_by_ref_seq(self, ngs_list):
logic = Logic.Logics()
result_dict = {}
print("get_pairwise2_needle_dict_by_ref_seq starts ")
for val_arr in self.ref_list:
ref_seq = val_arr[0]
for ngs_read_arr in ngs_list:
ngs_read = ngs_read_arr[0]
ngs_read_needle, needle_result, ref_seq_needle = logic.get_pairwise2_needle_result(
ngs_read, ref_seq)
needle_cnt = needle_result.count('|')
ins_cnt = ref_seq_needle.count("-")
del_cnt = ngs_read_needle.count("-")
needle_tot = len(needle_result)
sub_cnt = needle_tot - (needle_cnt + del_cnt + ins_cnt)
if ref_seq in result_dict:
result_dict[ref_seq].append(
[needle_cnt, ins_cnt, del_cnt, sub_cnt, ngs_read])
# TODO val_arr 이 너무 많은 경우 TOP_N 갯수 만큼 필터링 추가
sorted_list = logic.get_sorted_list_by_idx_ele(
result_dict[ref_seq], self.idx)
result_dict[ref_seq] = sorted_list[:self.top_n]
else:
result_dict.update({
ref_seq:
[[needle_cnt, ins_cnt, del_cnt, sub_cnt, ngs_read]]
})
return result_dict
def get_PAM_within_N_bp_of_POS(mut_list):
print("multi_processing ::: get_PAM_within_N_bp_of_PAM >>> ")
result_list = []
logic = Logic.Logics()
for mut_arr in mut_list:
chr_num = mut_arr[0]
pos = int(mut_arr[1]) - 1
ref_p_seq = mut_arr[3]
alt_p_seq = mut_arr[4]
ref_m_seq = ""
alt_m_seq = ""
try:
ref_m_seq += logic.make_complement_string(ref_p_seq)
if alt_p_seq == '.':
alt_p_seq = ""
else:
alt_m_seq += logic.make_complement_string(alt_p_seq)
except Exception as err:
print("make_complement_string ::: ", err)
print(ref_p_seq, " : ref_p_seq")
print(alt_p_seq, " : alt_p_seq")
print(str(mut_arr))
seq_record = SeqIO.read(REF_DIR + "chr" + chr_num + ".fa", "fasta")
p_seq = str(seq_record.seq).upper()
m_seq = str(seq_record.seq.complement()).upper()
logic.get_matched_pam_p_seq_list(result_list, p_seq, pos, PAM, WIN_PAM, SEQ_WIN_SIZE, "chr" + chr_num)
logic.get_matched_pam_m_seq_list(result_list, m_seq, pos, PAM, WIN_PAM, SEQ_WIN_SIZE, "chr" + chr_num)
print("DONE multi_processing ::: get_PAM_within_N_bp_of_PAM >>>")
return result_list
def get_pairwise2_needle_dict_simple(self, ngs_read_list):
print("get_pairwise2_needle_dict_ starts ")
logic = Logic.Logics()
result_dict = {}
alignments_result_dict = {}
fn_name = self.ref_list[0]
ref_seq = self.ref_list[1]
for np_arr in ngs_read_list:
ngs_read = np_arr[0]
ngs_id = np_arr[1]
ngs_read_needle, needle_result, ref_seq_needle, alignments_result = logic.get_pairwise2_needle_result(
ngs_read, ref_seq)
if fn_name in result_dict:
result_dict[fn_name].append(
[ngs_read_needle, needle_result, ref_seq_needle, ngs_id])
else:
result_dict.update({
fn_name:
[[ngs_read_needle, needle_result, ref_seq_needle, ngs_id]]
})
if fn_name in alignments_result_dict:
alignments_result_dict[fn_name].append([alignments_result])
else:
alignments_result_dict.update({fn_name: [[alignments_result]]})
return result_dict, alignments_result_dict
def get_guide_set_from_ref(p_sq, m_sq_no_rvrsed, gene_list, cds_dict,
init_arr):
logic = Logic.Logics()
result_set = set()
# len_f_guide = init_arr[1]
len_guide = init_arr[2]
pam_rule_arr = init_arr[3]
# len_b_pam = init_arr[4]
for gen_nm in gene_list:
cds_idx_list_arr = cds_dict[gen_nm]
for cds_idx_list in cds_idx_list_arr:
for clv_idx in cds_idx_list:
for pam_rule in pam_rule_arr:
len_pam = len(pam_rule)
pam_fr_p_sq = p_sq[clv_idx + 3:clv_idx + 3 + len_pam]
pam_fr_m_sq = m_sq_no_rvrsed[clv_idx - 3 -
len_pam:clv_idx - 3]
if logic.match_SY(0, pam_fr_p_sq, pam_rule):
guide_seq = p_sq[clv_idx + 3 - len_guide:clv_idx + 3]
result_set.add(guide_seq)
if logic.match_SY(0, pam_fr_m_sq, pam_rule[::-1]):
guide_seq = m_sq_no_rvrsed[clv_idx - 3:clv_idx - 3 +
len_guide]
result_set.add(guide_seq[::-1])
return result_set
def create_game(sprite_size, is_new):
global hero, engine, drawer, iteration
if is_new:
hero = Objects.Hero(base_stats, Service.create_sprite(
os.path.join("texture", "Hero.png"), sprite_size))
engine = Logic.GameEngine()
Service.service_init(sprite_size)
Service.reload_game(engine, hero)
drawer = SE.GameSurface((640, 480), pygame.SRCALPHA, (0, 480),
SE.ProgressBar((640, 120), (640, 0),SE.GameMiniMap((640, 150), (640, 150),
SE.InfoWindow((160, 600), (50, 50),
SE.HelpWindow((700, 500), pygame.SRCALPHA, (0, 0),
SE.ScreenHandle(
(0, 0))
)))))
else:
engine.sprite_size = sprite_size
hero.sprite = Service.create_sprite(
os.path.join("texture", "Hero.png"), sprite_size)
Service.service_init(sprite_size, False)
Logic.GameEngine.sprite_size = sprite_size
drawer.connect_engine(engine)
iteration = 0
def main1():
util = Util.Utils()
logic_prep = LogicPrep.LogicPreps()
logic = Logic.Logics()
seq_record = util.get_seq_record_from_genbank(WORK_DIR + NCBI +
genbank_file_name + ".gb")
cds_idx_list = logic_prep.get_cds_idx_arr_to_list(seq_record)
init_rule = INIT
pam_seq = init_rule[2]
plus_strand_list, minus_strand_list = logic.get_idx_of_matching_seq(
seq_record.seq, pam_seq)
plus_idx_list = logic.get_idx_in_list(plus_strand_list, cds_idx_list)
minus_idx_list = logic.get_idx_in_list(minus_strand_list, cds_idx_list,
False)
filtered_plus_idx_list = logic_prep.filter_out_dupl(plus_idx_list)
filtered_minus_idx_list = logic_prep.filter_out_dupl(minus_idx_list)
plus_seq_list = logic.get_trgt_seq_in_idx_list(seq_record.seq,
filtered_plus_idx_list,
init_rule)
minus_seq_list = logic.get_trgt_seq_in_idx_list(seq_record.seq,
filtered_minus_idx_list,
init_rule, False)
merge_list = logic_prep.merge_list([plus_seq_list, minus_seq_list])
tot_list = logic_prep.sort_list_by_ele(merge_list, 0)
header = ["sequence", "strand"]
def get_target_seq_with_clvg_site(self, path, init_arr):
logic = Logic.Logics()
tmp_dict = {}
pam_seq = init_arr[0]
add_seq1_len = init_arr[1]
spacer_len = init_arr[2]
add_seq2_len = init_arr[3]
clvg_site = init_arr[4]
pam_len = len(pam_seq)
std_tot_len = add_seq1_len + spacer_len + pam_len + add_seq2_len
for seq_record in SeqIO.parse(path, "fasta"):
tot_cds_len = len(seq_record.seq)
trncrpt_id = seq_record.id
if trncrpt_id not in tmp_dict:
tmp_dict.update({trncrpt_id: [seq_record.description]})
tmp_p_str = ""
idx = 0
for c in seq_record.seq:
idx += 1
tmp_p_str = tmp_p_str + c.upper()
if len(tmp_p_str) > std_tot_len:
tmp_p_str = tmp_p_str[-std_tot_len:]
if len(tmp_p_str) == std_tot_len:
if 'N' not in tmp_p_str:
if logic.match(0, tmp_p_str[-(add_seq2_len + pam_len):-add_seq2_len], pam_seq):
tmp_dict[trncrpt_id].append([tmp_p_str, ((idx - clvg_site - pam_len - add_seq2_len) / tot_cds_len) * 100])
return tmp_dict
def test():
util = Util.Utils()
logic = Logic.Logics([WORK_DIR + FASTQ_DIR])
brcd_list = util.read_tb_txt(WORK_DIR + BARCD_SEQ_FILE)
for brcd_arr in brcd_list:
print(brcd_arr)
def isEating(self, spot, oldSpot):
'''returns True if this spot will eat someone else which can also say that the player cant put there a new pawn (in a placement phase)'''
if len(self.naturalPawns) == 15: # cannot eat more
return (False, (-2, -2))
howManyIate = [] # only 1 allowed
otherTurn = (self.getTurn() + 1) % 2
eaten = (-1, -1)
triangles = Logic.vertexPartOfTriangle(spot)
for tri in triangles:
countA = 0
countB = 0
for vertex in tri:
if vertex == spot or vertex == oldSpot:
continue
if vertex in self.playersPawns[otherTurn]:
eaten = vertex
countA += 1
if vertex in self.playersPawns[self.getTurn()]:
countB += 1
if countA == 1 and countB == 1:
howManyIate.append(eaten)
if len(Set(howManyIate)
) == 1: # if i ate only one (or more but ate the same)
return (True, howManyIate[0])
return (False, (-1, -1))
def make_filtered_out_ClinVar_pos_in_cds_or_not():
logic = Logic.Logics()
logic_prep = LogicPrep.LogicPreps()
util = Util.Utils()
cds_info = util.read_csv_ignore_N_line(WORK_DIR + "input/" + ALL_CDS_INFO, "\t")
cds_dict_by_chr = {}
for cds_arr in cds_info:
chrom = cds_arr[2]
start_idx_arr, end_idx_arr = logic_prep.get_orf_strt_end_idx_arr(cds_arr)
idx_list = logic_prep.get_idx_num_frm_strt_to_end_list(start_idx_arr, end_idx_arr)
if chrom in cds_dict_by_chr:
cds_dict_by_chr[chrom].append(idx_list)
else:
cds_dict_by_chr.update({chrom: [idx_list]})
mut_dict = logic_prep.get_dict_from_list_by_ele_key(
util.read_csv_ignore_N_line(WORK_DIR + "input/" + MUT_INFO, "\t"), 0)
not_in_cds_list = []
in_cds_list = []
for chr_num, mut_list in mut_dict.items():
cds_idx_list = cds_dict_by_chr['chr' + chr_num]
for mut_arr in mut_list:
pos = int(mut_arr[1]) + ADJ_REF_IDX
tmp_id = int(mut_arr[2])
if not logic.check_seq_in_cds(cds_idx_list, pos):
not_in_cds_list.append(mut_arr)
else:
in_cds_list.append(mut_arr)
print(len(not_in_cds_list))
header = ['#CHROM', 'POS', 'ID', 'REF', 'ALT', 'QUAL', 'FILTER', 'INFO']
util.make_csv(WORK_DIR + '/input/ClinVar_dominant_mutation_on_CDS.txt', header, in_cds_list, deli='\t')
util.make_csv(WORK_DIR + '/input/ClinVar_dominant_mutation_not_on_CDS.txt', header, not_in_cds_list, deli='\t')
def multi_processing():
util = Util.Utils()
print("read FASTQ files path")
sources = util.get_files_from_dir(WORK_DIR + "FASTQ/" + '*.fastq')
print("read barcode list")
brcd_list = util.read_tb_txt(WORK_DIR + BARCD_SEQ_FILE)
logic = Logic.Logics(brcd_list)
print("get_FASTQ_seq_dict")
fastq_list = []
for sources_list in util.get_FASTQ_seq_dict(sources).values():
fastq_list.extend(sources_list)
# divide data_list by MULTI_CNT
splited_fastq_list = np.array_split(fastq_list, MULTI_CNT)
print("platform.system() : ", SYSTEM_NM)
print("total cpu_count : ", str(TOTAL_CPU))
print("will use : ", str(MULTI_CNT))
pool = mp.Pool(processes=MULTI_CNT)
## analyze FASTQ seq after barcode seq
pool_list = pool.map(logic.get_dict_multi_p_seq_from_FASTQ,
splited_fastq_list)
## analyze whole FASTQ seq
# pool_list = pool.map(logic.get_dict_multi_p_seq_from_whole_FASTQ, splited_fastq_list)
merge_dict = logic.merge_pool_list(pool_list)
util.make_dict_to_excel(
WORK_DIR + "output/result_count_" +
BARCD_SEQ_FILE.replace("barcode_seq/", "").replace(".txt", ""),
merge_dict)
def multi_processing_test():
util = Util.Utils()
sources = util.get_files_from_dir(WORK_DIR + "FASTQ/" + '*.fastq')
brcd_list = util.read_tb_txt(WORK_DIR + BARCD_SEQ_FILE)
logic = Logic.Logics(brcd_list)
# key : D:/000_WORK/JangHyeWon_ShinJeongHong/20200604/WORK_DIR/FASTQ\\18.fastq
fastq_list = util.get_FASTQ_seq_dict(
sources
)['D:/000_WORK/JangHyeWon_ShinJeongHong/20200604/WORK_DIR/FASTQ\\18.fastq']
# divide data_list by MULTI_CNT
splited_fastq_list = np.array_split(fastq_list, MULTI_CNT)
print("platform.system() : ", SYSTEM_NM)
print("total cpu_count : ", str(TOTAL_CPU))
print("will use : ", str(MULTI_CNT))
pool = mp.Pool(processes=MULTI_CNT)
# result_list = pd.concat(pool.map(logic.get_multi_p_seq_from_FASTQ, splited_fastq_list))
pool_list = pool.map(logic.get_list_multi_p_seq_from_FASTQ,
splited_fastq_list)
result_list = []
for tmp_list in pool_list:
result_list.extend(tmp_list)
util.make_list_to_excel(WORK_DIR + "result_multi_processing", result_list)
def Start_Game(self): # Begin the game, run the updates needed.
self.Game = lgc.Game(**self.GameParams)
self.Game.Start_Game()
# Update Game page
self.Update_Game()
self.Window.Pages["Game"].Update_Game_Type()
def confirm_move(self):
num = askinteger("Troops:", "Enter number of troops :", parent=self)
if num == 0:
showerror("Error", "Kuch to hila")
else:
result = None
if self.selected.cannon:
if askyesno("Move cannon?", parent=self):
result = Logic.move(self.selected, self.selected_2, num, True, 0, 0)
else:
result = Logic.move(self.selected, self.selected_2, num, False, 0, 0)
else:
result = Logic.move(self.selected, self.selected_2, num, False, 0, 0)
if result[0]:
self.next_move()
else:
showerror("Error", result[1])
self.selected_2 = None
self.state = SELECT
self.update_ui()
self.update_menu()
def update_ui(self):
self.canvas.create_image(0, 0, anchor=tk.NW, image=self.BG)
for n in Logic.network:
self.canvas.create_image(n.x, n.y, anchor=tk.CENTER, image=self.NODE_IMG[n.rank])
if n.occupant == PLAYER_AXIS:
self.canvas.create_image(n.x, n.y - NODE_R[n.rank] - 5, anchor=tk.S, image=self.FLAG_AXIS)
if n.occupant == PLAYER_ALLY:
self.canvas.create_image(n.x, n.y - NODE_R[n.rank] - 5, anchor=tk.S, image=self.FLAG_ALLY)
if n.cannon or n.cannon_time > -1:
self.canvas.create_image(n.x - NODE_R[n.rank] - 5, n.y, anchor=tk.E, image=self.CANNON)
if n.cannon_time > -1:
self.canvas.create_text(
n.x - NODE_R[n.rank] - 5, n.y + NODE_R[n.rank] + 5, anchor=tk.NE, text=str(Logic.cannon_makers)
)
if n.fortress or n.fortress_time > -1:
self.canvas.create_image(n.x + NODE_R[n.rank] + 5, n.y, anchor=tk.W, image=self.FORTRESS)
if n.fortress_time > -1:
self.canvas.create_text(
n.x + NODE_R[n.rank] + 5, n.y + NODE_R[n.rank] + 5, anchor=tk.NW, text=str(Logic.fortress_makers)
)
self.canvas.create_text(n.x, n.y + NODE_R[n.rank] + 5, anchor=tk.N, text=str(n.allowed))
if self.selected is not None:
self.canvas.create_oval(
self.selected.x - NODE_R[self.selected.rank] - 5,
self.selected.y - NODE_R[self.selected.rank] - 5,
self.selected.x + NODE_R[self.selected.rank] + 5,
self.selected.y + NODE_R[self.selected.rank] + 5,
width=3,
outline="#0000FF",
)
for n in Logic.adjacent_levels(self.selected):
self.canvas.create_line(self.selected.x, self.selected.y, n.x, n.y, arrow=tk.LAST, dash=(3, 3))
if self.selected_2 is not None:
self.canvas.create_oval(
self.selected_2.x - NODE_R[self.selected_2.rank] - 5,
self.selected_2.y - NODE_R[self.selected_2.rank] - 5,
self.selected_2.x + NODE_R[self.selected_2.rank] + 5,
self.selected_2.y + NODE_R[self.selected_2.rank] + 5,
width=3,
outline="#FF0000",
)
def eval(formula, v):
'''
Evaluate the formula with the given valuation
'''
if (hasattr(formula, "type")): # houston we have a leaf
if formula.type is Parse.typeConstBool:
return formula.value
elif formula.type is Parse.typeVar:
return valuation(formula.value, v)
else: # operator
token = formula[0]
op_fun = Logic.get_op(token.value)
if token.type is Parse.typeDual:
left = formula[1]
right = formula[2]
return op_fun(eval(left, v), eval(right, v))
elif token.type is Parse.typeSingle:
return op_fun(eval(formula[1], v))
for round in range(6*2):
t0s, t1s = BattleFrame.getResults(round%2==0, game_master.team_arrays[0], game_master.team_arrays[1])
game_master.team0[t0s].select(game_master)
game_master.team1[t1s].select(game_master)
game_master.battlepixie0[0].tween()
game_master.battlepixie1[0].tween()
game_master.animate_combat(abs(round%2-1))
color0 = game_master.battlepixie0[0].get_color()
color1 = game_master.battlepixie1[0].get_color()
if(round%2==0):
pts0 -= math.floor(Logic.getPoints(color0,color1)*50)
else:
pts1 -= math.floor(Logic.getPoints(color1,color0)*50)
if pts0<=0 or pts1<=0:
break
game_master.apply_damage(1,pts1)
game_master.apply_damage(0,pts0)
game_master.draw_health()
game_master.return_pixies()
print "===Points==="
print "Team 0 points: ", int(pts0)
print "Team 1 points: ", int(pts1)
print ""
def mk_fortress(self):
result = Logic.move(self.selected, None, 0, False, 0, 1)
if result[0]:
self.next_move()
else:
showerror("Error", result[1])
def mk_cannon(self):
result = Logic.move(self.selected, None, 0, False, 1, 0)
if result[0]:
self.next_move()
else:
showerror("Error", result[1])
game_master.draw_pixies(game_master.team1)
pts0 = 0
pts1 = 0
for round in range(6*2):
t0s, t1s = BattleFrame.getResults(round%2==0, game_master.team_arrays[0], game_master.team_arrays[1])
game_master.team0[t0s].select(game_master)
game_master.team1[t1s].select(game_master)
if round-1>=0:
for i in range(0,round):
game_master.battlepixie0[i].go_home()
game_master.battlepixie1[i].go_home()
game_master.battlepixie0[round].tween()
game_master.battlepixie1[round].tween()
color0 = game_master.battlepixie0[round].get_color()
color1 = game_master.battlepixie1[round].get_color()
if(round%2==0):
pts0 += math.floor(Logic.getPoints(color0,color1)*100)
else:
pts1 += math.floor(Logic.getPoints(color1,color0)*100)
print "===Points==="
print "Team 0 points: ", int(pts0)
print "Team 1 points: ", int(pts1)
print ""
count=1
speed=0
steer=0
timer=0
deltaL=0
deltaR=0
encoder=Encoder()
navigation=Navigation()
scanner=Scanner()
karte=Karte(encoder)
plan=Plan()
kreis=0
motor=Motor()
grid=Grid(50,50)
logic=Logic()
manuell=Manuell()
json=Json()
weggeber=Weggeber()
grid.setZielInGrid(35,20)
grid.setStartInGrid(1,1)
karte.setRoboPosZero(0,0)
plan.setGlobalZiel(150,0)
def cleaning():
"""Do cleanup at end, command are visVersa"""
motor.setCommand(0,0)
atexit.register(cleaning)
#SCAN OFF
def menu():
print(" SGL Simulator in Pyhton.\nMenu:")
print(" 1. New File. \n 2. Compile. \n 3. Exit")
opt = input(" Select: # ")
while opt != "3":
lista1 = []
trad_list = []
if opt == "1":
file_name = input("File name: ") # Lectura del nombre por asignar al archivo
print("Type your code in SGL. Enter 'END' for finish")
Logic.read_lines(lista1) # Lextura de Lineas
trad_list = Logic.loop_lines(lista1, Logic.var_type) # comparacion con matrizes
trad_list = Logic.loop_lines(trad_list, Logic.loop)
trad_list = Logic.loop_lines(trad_list, Logic.function)
trad_list = Logic.loop_lines(trad_list, Logic.conditional)
Logic.new_file_py(file_name) # Creacion de ARCHIVO
Logic.save_data_file(trad_list, file_name) # Ingreso de lineas de codigo en python al archivo
# en prueba "Error de codigo"
#if not Logic.compare_lists(trad_list, lista1):
# print("\n Error code online, incorrect or missing command syntax or operands!")
opt = input("Finish...\nRequires to perform another operation? y/n:") # Verifica si necesita realizar mas operaciones.
if opt == "n":
opt = "3"
elif opt == "N":
opt = "3"
else:
opt = "4"
elif opt == "2":
print("Put your file into ' generate_files ' folder and enter the name of the file to compile . ")
try:
file_name = input("File name: ")
trad_list = Logic.open_compile(file_name) # Lectura del nombre por asignar al archivo
trad_list = Logic.loop_lines(trad_list, Logic.var_type) # comparacion con matrizes
trad_list = Logic.loop_lines(trad_list, Logic.loop)
trad_list = Logic.loop_lines(trad_list, Logic.function)
trad_list = Logic.loop_lines(trad_list, Logic.conditional)
Logic.new_file_py(file_name) # Creacion de ARCHIVO
Logic.save_data_file(trad_list, file_name) # Ingreso de lineas de codigo en python al archivo
print("Successfully compiled file")
except:
print("\n", FileNotFoundError, "Check File's Name")
opt = input("Finish...\nRequires to perform another operation? y/n:") # Verifica si necesita realizar mas operaciones.
if opt == "n":
opt = "3"
elif opt == "N":
opt = "3"
else:
opt = "4"
elif opt == "4": # si la opcion fue 4 significa que desean seguir trabajando
print("\n\n")
print(" SGL Simulator in Pyhton.\nMenu:")
print(" 1. New File. \n 2. Compile. \n 3. Exit")
opt = input(" Select: # ")
else: # si digitan un digito fuera de las opciones lanza de nuevo el menu.
print("Invalid option. Choose again.\n\n")
print(" SGL Simulator in Pyhton.\nMenu:")
print(" 1. New File. \n 2. Compile. \n 3. Exit")
opt = input(" Select: # ")
screen = pygame.display.set_mode((800, 600))
pygame.display.set_caption("Space Invaders")
background = pygame.Surface((800, 600))
background.fill(background_color)
clock = pygame.time.Clock()
menu = Menu()
END_MUSIC_EVENT = pygame.USEREVENT + 0
pygame.mixer.music.set_endevent(END_MUSIC_EVENT)
sound = pygame.mixer.Sound("background.wav")
sound.play()
logic = Logic(pygame, screen)
ship = Ship(pygame, screen)
particle = Particle(pygame, screen,logic,0,0)
handler = EventHandler()
while clear():
for event in pygame.event.get():
if event.type == QUIT:
sys.exit()
elif event.type == pygame.KEYDOWN or event.type == pygame.KEYUP:
handler.handle(event, pygame, screen, ship)
elif event.type == END_MUSIC_EVENT and event.code == 0:
sound.play()
logic.hit_ship()
