def mask_genes(self): for chr in self.get_chrs(): #fh = open(get_path("reference_sequence." + chr + ".fasta"), "r") #line = fh.readline() #seq = fh.readline() #fh.close #print(chr, line, len(seq)) line, fseq = self.get_header_seq("reference_sequence." + chr + ".fasta") rseq = fseq print(chr, line, len(fseq)) out = self.get_stend_pos_genes(chr) #print(seq[335517:336000]) for row in out: #print(row['start'], row['end']); st = int(row['start']) - 1 en = int(row['end']) xing = "X" * (en - st) if row['strand'] == '+': fseq = fseq[:st] + xing + fseq[en:] if row['strand'] == '-': rseq = rseq[:st] + xing + rseq[en:] #print(seq[335517:336000]) fh = open(get_path("reference_sequence." + chr + ".masked.forward.fasta"), "w") fh.write(line + fseq) fh.close() fh = open(get_path("reference_sequence." + chr + ".masked.reverse.fasta"), "w") fh.write(line + rseq) fh.close()
def print_value(cbor_data): path = helpers.get_path() if len(path) == 1: return cbor_data else: path.pop(0) return get_value(path, cbor_data)
def a_star(maze, start, goal): pq = PriorityQueue() # In the A* trace we said that the F value for the initial cell position would be equal to # the H value...but we are not required to have to calculate that manually because there's only # going to be one item on the queue at this point, it will automatically # have the highest priority so we can set it equal to 0 pq.put(start, 0) predecessors = {start: None} g_values = {start: 0} # In our representation of these mazes, we have cells connected by edges and the weight # of each edge is just one. So the new cost is just one more than the previous cost # putting it in g values and in predecessors is equivalent to saying *we've discovered this while not pq.is_empty(): current_cell = pq.get() if current_cell == goal: return get_path(predecessors, start, goal) for direction in ["up", "right", "down", "left"]: row_offset, col_offset = offsets[direction] neighbour = (current_cell[0] + row_offset, current_cell[1] + col_offset) if is_legal_pos(maze, neighbour) and neighbour not in g_values: new_cost = g_values[current_cell] + 1 g_values[neighbour] = new_cost f_value = new_cost + heuristic(goal, neighbour) pq.put(neighbour, f_value) predecessors[neighbour] = current_cell return None
def dfs(maze, start, goal): # We instantiate a new stack stack = Stack() # We're pushing our start position which is a coordinate/row, column tuples (an immutable list) stack.push(start) # predecessors is a dictionary containing the predecessor of the start position, which is none predecessors = {start: None} while not stack.is_empty(): # While the stack is not empty, we get the current cell by popping current_cell = stack.pop() # We check if it's the goal, if it is, the program is finished! if current_cell == goal: return get_path(predecessors, start, goal) # Otherwise, for every direction in this list, we check the offsets (imported from helper # file and we assign the i, j values from from that so that we can then check the neighbor # The whole point of this is to check the coordinates of the contiguous cells in all four directions for direction in ["up", "right", "down", "left"]: row_offset, col_offset = offsets[direction] # neighbor refers to the cell neighbor = (current_cell[0] + row_offset, current_cell[1] + col_offset) # now we say, for each of those directions, if it's a legal position and it doesn't already exist in our # predecessors list, that means we haven't discovered it yet - so we push it on to our stack. if is_legal_pos(maze, neighbor) and neighbor not in predecessors: # finally we push the neighbor on the stack and update the predecessors stack.push(neighbor) predecessors[neighbor] = current_cell return None
def update_value(cbor_data): path = helpers.get_path() new_data = input(messages.tool_update_request) if len(path) == 1: return new_data else: path.pop(0) return change_value(path, cbor_data, new_data)
def say(self, text): from config import USE_TTS_LANGUAGE # Fetch the fill path for the tts_result.mp3 in which the TTS results will be saved file_name = get_path('/resources/audio/tts_result.mp3') if os.path.isfile(file_name) is False: debug(str(file_name) + "File does not exists") tts = gTTS(text=str(text), lang=USE_TTS_LANGUAGE) tts.save(file_name) self.play_mp3_file(file_name)
def listen(self): r = sr.Recognizer() with sr.Microphone() as source: debug("Say something!") audio = r.listen(source) # Write audio to a file which we will send to the API with open(get_path("/resources/audio/microphone-results.wav"), "wb") as f: f.write(audio.get_wav_data())
def dfs(maze, start, goal, pred={}): offs = { "down": (1, 0), "right": (0, 1), "up": (-1, 0), "left": (0, -1), } res_pred = dfs1(maze, start, goal, offs, {}, [False]) print(res_pred) return get_path(res_pred, start, goal)
def brute_force(start, goal, max_reactions, reaction_dict): print_list = [] print_list.append((start, "starting molecule")) print_list.append((goal, "goal molecule")) counter = 0 start_node = molecule_path_node(start, 0, 0, "start") lst = [start_node] returnv = False while (lst[counter].reactions < max_reactions and (not (test_molecule_isomorphism((lst[counter].molec), goal)))): #x = deepcopy(lst[counter].molec) for j in reaction_dict: # apply every possible reaction x = deepcopy(lst[counter].molec) products = reaction_dict[j](x) product_nodes = [] for i in products: product_nodes.append( molecule_path_node(i, counter, lst[counter].reactions + 1, j)) lst = lst + product_nodes counter = counter + 1 if test_molecule_isomorphism(lst[counter].molec, goal): print_list = print_list + (get_path(lst, counter)) print(lst[counter].molec.bonds) # here print(goal) returnv = True else: while counter < len(lst): if test_molecule_isomorphism(lst[counter].molec, goal): print_list = print_list + (get_path(lst, counter)) print(lst[counter].molec.bonds) # here print(goal) returnv = True break else: counter = counter + 1 #print(test_molecule_isomorphism(lst[counter].molec, goal)) print(returnv) return print_list
def split_promoters(self): fh = open(get_path('promoters.sql.10000.txt'), 'r') fh_5000 = open(get_path('promoters.sql.5000.txt'), 'w') fh_2000 = open(get_path('promoters.sql.2000.txt'), 'w') fh_1000 = open(get_path('promoters.sql.1000.txt'), 'w') fh_500 = open(get_path('promoters.sql.500.txt'), 'w') for line in fh: line = line.rstrip("\r|\n") cols = line.split("\t") astring = "\t".join(cols[0:5]) print(astring) fh_5000.write(astring + "\t" + cols[5][0:5001] + "\n") fh_2000.write(astring + "\t" + cols[5][0:2001] + "\n") fh_1000.write(astring + "\t" + cols[5][0:1001] + "\n") fh_500.write(astring + "\t" + cols[5][0:501] + "\n") fh_5000.close() fh_2000.close() fh_1000.close() fh_500.close() fh.close()
def get_intent(self, audio_path): # Create the API client client = Wit(api_key) # Send the .wav file we've created earlier to the API try: with open(get_path('/resources/audio/microphone-results.wav'), 'rb') as f: resp = client.speech(f, None, {'Content-Type': 'audio/wav'}) return resp except: debug("Microphone-results failed to open")
def bfs(start,goal): # dimension of the square puzzle n = len(start) # offsets for movements in the list offsets = { "right": 1, "left": -1, "up": -n, "down": n } # converting matrix to string start_state = "".join(matrix_to_lst(start)) goal_state = "".join(matrix_to_lst(goal)) queue = Queue() queue.enqueue(start_state) predecessors = {start_state: None} while not queue.is_empty(): # pop off first state in the queue current_state = queue.dequeue() # check if it is the goal itself if current_state == goal_state: return get_path(predecessors, start_state, goal_state) current_state_lst = list(current_state) # convert string to list, because swap is not possible on strings(immutable) blank_pos = current_state_lst.index('A') # find position of blank tile for direction in ["up", "right", "down", "left"]: current_copy = copy.deepcopy(current_state_lst) # deepcopy to protect current_state_lst itself from modification new_blank_pos = blank_pos + offsets[direction] if new_blank_pos >= 0 and new_blank_pos < n**2 : # check for valid location before swapping tile current_copy[blank_pos], current_copy[new_blank_pos] = current_copy[new_blank_pos], current_copy[blank_pos] # swap operation neighbour = "".join(current_copy) # convert to string else: continue # if invalid location, continue to next direction if neighbour not in predecessors: queue.enqueue(neighbour) # add neighbour to exploration queue predecessors[neighbour] = current_state # add neighbour to the parent-child dictionary for backtracking return None
def bfs(maze, start, goal): q = Queue() q.enqueue(start) pred = {start: None} while (not q.is_empty()): cc = q.dequeue() if cc == goal: return get_path(pred, start, goal) else: for key, value in offsets.items(): newpos = tuple(cc[i] + value[i] for i in range(len(cc))) if is_legal_pos(maze, newpos) and newpos not in pred: q.enqueue(newpos) pred[newpos] = cc
def bfs(maze, start, goal): queue = Queue() queue.enqueue(start) predecessors = {start: None} while not queue.is_empty(): current_cell = queue.dequeue() if current_cell == goal: return get_path(predecessors, start, goal) for direction in ["up", "right", "down", "left"]: row_offset, col_offset = offsets[direction] neighbor = (current_cell[0] + row_offset, current_cell[1] + col_offset) if is_legal_pos(maze, neighbor) and neighbor not in predecessors: queue.enqueue(neighbor) predecessors[neighbor] = current_cell return None
def dfs(maze, start, goal): stack = Stack() stack.push(start) predecessors = {start: None} while not stack.is_empty(): current_cell = stack.pop() if current_cell == goal: return get_path(predecessors, start, goal) for direction in ["up", "right", "down", "left"]: row_offset, col_offset = offsets[direction] neighbour = (current_cell[0] + row_offset, current_cell[1] + col_offset) if is_legal_pos(maze, neighbour) and neighbour not in predecessors: stack.push(neighbour) predecessors[neighbour] = current_cell return None
def a_star(maze, start, goal): def fval(cur): return fval1(cur, start, goal) prq = PriorityQueue() prq.put(start, fval(start)) pred = {start: None} while not prq.is_empty(): cc = prq.get() if cc == goal: return get_path(pred, start, goal) for key, value in offsets.items(): newpos = tuple(cc[i] + value[i] for i in range(len(cc))) if is_legal_pos(maze, newpos) and newpos not in pred: prq.put(newpos, fval(newpos)) pred[newpos] = cc
def get_promoters(self): fh = open(get_path("promoters.sql.10000.txt"), "w") for dir in ["forward", "reverse"]: for chr in self.get_chrs(): print(chr) line, seq = self.get_header_seq("reference_sequence." + chr + ".masked."+dir+".fasta") out = self.get_stend_pos_genes(chr) for row in out: if row['strand'] == '+' and dir == "forward": st, en, pro = self.toleft(seq, row['start'], 10000) fh.write(row['gene_id'] +"\t"+ chr +"\t"+ st +"\t"+ en +"\tupstream\t"+ pro +"\n") st, en, pro = self.toright(seq, row['end'], 10000) fh.write(row['gene_id'] +"\t"+ chr +"\t"+ st +"\t"+ en +"\tdownstream\t"+ pro +"\n") if row['strand'] == '-' and dir == "reverse": st, en, pro = self.toright(seq, row['end'], 10000) fh.write(row['gene_id'] +"\t"+ chr +"\t"+ st +"\t"+ en +"\tdownstream\t"+ pro +"\n") st, en, pro = self.toleft(seq, row['start'], 10000) fh.write(row['gene_id'] +"\t"+ chr +"\t"+ st +"\t"+ en +"\tupstream\t"+ pro +"\n") fh.close()
def split_fasta_file(self): fh = open(get_path(self.filename), "r") pre = '' seq = '' for line in fh: line = line.rstrip("\r|\n") if ">" in line: chr = re.search('>chr([0-9A-Za-z]*) ', line).group(1) #print(pre, chr, line) if seq != '' and pre != chr: #print(">", pre, "\n", seq, "\n") self.save_chromosome(pre, seq) pre = chr seq = '' else: pre = chr else: seq += line #print(">", pre, "\n", seq, "\n") self.save_chromosome(pre, seq)
def a_star(maze, start, goal): pq = PriorityQueue() # technically, the 0 should have the heuristic distance, but this is not necessary pq.put(start, 0) predecessors = {start: None} g_values = {start: 0} while not pq.is_empty(): current_cell = pq.get() if current_cell = goal: return get_path(predecessors, start, goal) for direction in ["up","right","down","left"]: row_offset, col_offset = offsets[direction] neighbor = (current_cell[0] + row_offset, current_cell[1] + col_offset) if is_legal_pos(maze, neighbor) and neighbor not in g_values: new_cost = g_values[current_cell] + 1 g_values[neighbor] = new_cost f_value = new_cost + heuristic(goal, neighbor) pq.put(neighbor, f_value) predecessors[neighbor] = current_cell
def custom_generator(num_docs, batch_size, set='tr'): path = helpers.get_path(num_docs, set) counter = 0 curr_pos = 0 num_batches = num_docs // batch_size while True: x_batch, y_batch, curr_pos = data_operations.read_dumps_in_batches(path, batch_size, curr_pos) avg_doc_len = helpers.find_avg_doc_length_in_batch(x_batch) x_batch = pad_sequences(x_batch, avg_doc_len, padding='post', truncating='post', dtype=np.float32) # (batch_size, doc_len, sen_len) y_batch = pad_sequences(y_batch, avg_doc_len, padding='post', truncating='post', dtype=np.float32) # (batch_size, doc_len) print(f'AVG DOC LEN: {avg_doc_len}') counter += 1 # converting from np.array to tensor because of https://github.com/tensorflow/tensorflow/issues/44705#issuecomment-725803328 yield tf.convert_to_tensor(x_batch), tf.convert_to_tensor(np.reshape(y_batch, (y_batch.shape[0], y_batch.shape[1], 1))) # restart counter to yield data in the next epoch as well if counter >= num_batches: counter = 0 curr_pos = 0
def dfs(maze, start, goal): stack = Stack() stack.push(start) predecessors = {start: None} while not stack.is_empty(): # getting the top item from the stack (far most right item) current_cell = stack.pop() if current_cell == goal: return get_path(predecessors, start, goal) for direction in ["up", "right", "down", "left"]: # unpacking the tuple row_offset, col_offset = offsets[direction] neighbor = (current_cell[0] + row_offset, current_cell[1] + col_offset) if is_legal_pos(maze, neighbor) and neighbor not in predecessors: stack.push(neighbor) predecessors[neighbor] = current_cell return None # pass only prevents the code from returning an error if you run it pass
def get_header_seq(self, filename): fh = open(get_path(filename), "r") line = fh.readline() seq = fh.readline() fh.close return line, seq
from config import USE_NLP_LANGUAGE from helpers import get_path import configparser config = configparser.ConfigParser() config_path = get_path("NLP/nlp.config") config.read(config_path) _api_key_name = 'nlp_api_' + USE_NLP_LANGUAGE api_key = config.get(_api_key_name, 'wit')
import pyowm from helpers import debug, get_path import configparser from config import USE_TTS_LANGUAGE config = configparser.ConfigParser() config_path = get_path("Weather/weather.config") config.read(config_path) class UsesApiKey: api_key = None class BaseWeatherProvider: location = None def get_current_weather(self): raise NotImplementedError() def set_location(self, location): self.location = location class OpenWeatherMap(UsesApiKey, BaseWeatherProvider): client = None weather = None def __init__(self):
from App.App import App import gettext from config import USE_POPPY_LANGUAGE from helpers import get_path import locale locale_path = get_path('/locale') print("Locale path: " + locale_path) lang = gettext.translation('poppy', localedir=locale_path, languages=[USE_POPPY_LANGUAGE]) lang.install() locale.setlocale(locale.LC_ALL, USE_POPPY_LANGUAGE) app = App()