def addOrganism(org_name, org_desc, chrs_count): LOG.INFO("Rozpoczynam dodawanie organizmu: " + str(org_name) + ". Ilosc chromosomow: " + str(chrs_count) + ". Opis: " + str(org_desc)) organism = None try: organism = Organism(name=str(org_name), description=str(org_desc)) organism.save() LOG.DEBUG("Dodano organizm: " + str(organism.id)) except Exception: LOG.WARN("Blad podczas dodawania nowego organizmu: " + str(org_name)) return None try: # Dodanie wszystkich chromosomow for i in range(chrs_count): chr = Chromosome(name=("Chromosome " + str(i + 1)), organism_id=int(organism.id)) chr.save() LOG.DEBUG("Dodano chromosom: " + str(chr.name) + " (" + str(chr.id) + ")" + " do organizmu: " + str(chr.organism_id)) except Exception: LOG.WARN("Blad podczas dodawania nowego chromosomu do organizmu: " + str(org_name)) return None LOG.INFO("Zakonczylem dodawanie organizmu: " + str(org_name)) return organism.id
def getChromosomeByID(chr_id): LOG.INFO("Rozpoczynam pobieranie obiektu chromosomu o ID: " + str(chr_id)) chromosome = Chromosome.objects.filter(id=int(chr_id)).values() try: chromosome_ret = chromosome[0] except IndexError: LOG.WARN("Nie istnieje chromosom o ID: " + str(chr_id)) return None LOG.DEBUG("Pobieram typy asemblacji organizmu: " + str(chromosome_ret['organism_id'])) # Pobranie pierwszego typu asemblacji danego organizmu org_assembs = Assemb.objects.filter( organism_id=int(chromosome_ret['organism_id'])) if len(org_assembs) == 0: return None LOG.DEBUG("Typy asemblacji organizmu: " + str(chromosome_ret['organism_id']) + ": " + str(org_assembs)) # Wybieramy tego, ktory jest najdluzszy sumarycznie ass_lenghts = {} for ass in org_assembs: chr_len_objs = ChromosomeLength.objects.filter(assemb_id=ass.id) total_len = 0.0 for chr_len_obj in chr_len_objs: total_len += chr_len_obj.length LOG.DEBUG("Typ asemblacji: " + str(ass) + ". Sumaryczna dlugosc: " + str(total_len)) ass_lenghts[ass.id] = total_len max_assemb = max(ass_lenghts, key=ass_lenghts.get) LOG.DEBUG("Typ asemblacji o najwiekszej sumie dlugosci chromosomow: " + str(max_assemb)) if max_assemb == 0.0: LOG.DEBUG("Najdluzszy chromosom ma 0 dlugosc.") return None try: chr_len = ChromosomeLength.objects.get(chr_id=chromosome_ret['id'], assemb_id=max_assemb) except ChromosomeLength.DoesNotExist: LOG.WARN("Chromosome o ID: " + str(chr_id) + " nie ma zadnej dlugosci.") return None print "Dlugosc:", chr_len chromosome_ret['length'] = chr_len.length LOG.INFO("Zakonczylem pobieranie obiektu chromosomu o ID: " + str(chr_id)) return chromosome_ret
def deleteChromosome(chr_id): LOG.INFO("Rozpoczynam usuwanie chromosomu o ID: " + str(chr_id)) try: chr = Chromosome.objects.get(id=int(chr_id)) except Chromosome.DoesNotExist: LOG.WARN("Brak chromosomu o ID: " + str(chr_id)) return None chr.delete() LOG.DEBUG("Usuwam wszystkie dlugosci chromosomow z chromosomu: " + str(chr_id)) # Usuniecie wszystkich ChromosomeLength try: ChromosomeLength.objects.filter(chr_id=int(chr_id)).delete() except Exception: LOG.DEBUG("Brak dlugosci chromosomu: " + str(chr_id)) LOG.DEBUG("Usuwam wszystkie scaffoldy wraz z contigami z chromosomu: " + str(chr_id)) # Usuniecie wszystkich Scaffoldow, ScaffoldPositions oraz Contigs scaffs = Scaffold.objects.filter(chromosome_id=int(chr_id)) for scaff in scaffs: deleteScaffold(scaff.id, True) LOG.INFO("Zakonczylem usuwanie chromosomu o ID: " + str(chr_id))
def getContigFromTree(start, stop): contigs_return = [] if ContigsTreeObject.interval_tree == None: return contigs_return LOG.INFO("Rozpoczynam poszukiwanie contigow w drzewie. Od " + str(start) + " do " + str(stop)) contigs_result = ContigsTreeObject.interval_tree.find(start, stop) i = 0 for contig in contigs_result: # Obiekt contigu try: cont = Contig.objects.all().get(id = contig.contig_id) except Contig.DoesNotExist: LOG.WARN("Brak contigu o ID: " + str(contig.contig_id)) return None #cont_wrap = ContigWrap(cont.id, cont.scaff_id, cont.order, cont.start, cont.end, cont.sequence, cont.length_bp) contigs_return.append(cont) i += 1 contigs_return.sort(key = lambda x: x.scaff_id, reverse = False) contigs_return.sort(key = lambda x: x.start, reverse = False) LOG.DEBUG("Wynik poszukiwan (" + str(start) + " - " + str(stop) + "):\n" + str(contigs_return)) LOG.INFO("Zakonczylem przeszukiwanie contigow w drzewie.") return contigs_return
def getMarkerFromScaffoldTree(start, stop): LOG.INFO("Rozpoczynam poszukiwanie markerow w drzewie (s). Od " + str(start) + " do " + str(stop)) markers_return = [] LOG.DEBUG("Drzewo markerow (s): " + str(MarkersScaffoldTreeObject.interval_tree)) if MarkersScaffoldTreeObject.interval_tree == None: LOG.DEBUG("Drzewo markerow nie zostalo zbudowane!") return None markers_result = MarkersScaffoldTreeObject.interval_tree.find(start, stop) i = 0 for marker in markers_result: # Obiekt markera try: mar = Marker.objects.all().get(name = marker.marker_name) except Marker.DoesNotExist: LOG.WARN("Brak contigu o ID: " + str(marker.marker_name)) return None markers_return.append(mar) i += 1 markers_return.sort(key = lambda x: x.scaff_id, reverse = False) markers_return.sort(key = lambda x: x.scaffold_start, reverse = False) LOG.DEBUG("Wynik poszukiwan markerow (" + str(start) + " - " + str(stop) + "):\n" + str(markers_return)) LOG.INFO("Zakonczylem przeszukiwanie markerow w drzewie.") return markers_return
def getTextResultKMP(scaff, pattern): scaff_id, start_index = str(scaff).split(";") try: scaff = Scaffold.objects.get(id=scaff_id) except Scaffold.DoesNotExist: LOG.WARN("Scaffold o ID: " + str(scaff_id) + " nie istnieje!") return None start_index = int(start_index) scaff_seq = scaff.sequence start = '<b><font color="blue">' if start_index < 10: prefix = scaff_seq[:start_index] else: prefix = scaff_seq[start_index - 10:start_index] content = scaff_seq[start_index:start_index + len(pattern)] end = '</font></b>' if start_index + len(pattern) + 10 > len(scaff_seq): sufix = scaff_seq[start_index + len(pattern):] else: sufix = scaff_seq[start_index + len(pattern):start_index + len(pattern) + 10] return (prefix + start + content + end + sufix)
def getMarker(marker_name): LOG.INFO("Rozpoczynam pobieranie markera o nazwie: " + str(marker_name)) try: m = Marker.objects.all().get(name = str(marker_name)) except Marker.DoesNotExist: LOG.WARN("Brak markera o nazwie: " + str(marker_name)) return None LOG.INFO("Zakonczylem pobieranie markera o nazwie: " + str(marker_name)) return m
def deleteCongit(cont_id): LOG.INFO("Rozpoczynam usuwanie contigu o ID: " + str(cont_id)) try: c = Contig.objects.get(id = int(cont_id)) except Contig.DoesNotExist: LOG.WARN("Brak contigu o ID: " + str(cont_id)) return None c.delete() return True
def getContig(cont_id): LOG.INFO("Rozpoczynam pobieranie contigu o ID: " + str(cont_id)) try: c = Contig.objects.all().get(id = int(cont_id)) except Contig.DoesNotExist: LOG.WARN("Brak contigu o ID: " + str(cont_id)) return None #cont_wrap = ContigWrap(c.id, c.scaff_id, c.order, c.start, c.end, c.sequence, c.length_bp) LOG.INFO("Zakonczylem pobieranie contigu o ID: " + str(cont_id)) return c
def getAssembName(assemb_id): LOG.INFO("Rozpoczynam pobieranie nazwy typu asemblacji o ID: " + str(assemb_id)) try: assemb = Assemb.objects.get(id=int(assemb_id)) except Assemb.DoesNotExist: LOG.WARN("Nie istnieje typ asemblacji o ID: " + str(assemb_id)) return None LOG.INFO("Zakonczylem pobieranie nazwy typu asemblacji o ID: " + str(assemb_id)) return assemb.name
def getAssembByID(assemb_id): LOG.INFO("Rozpoczynam pobieranie obiektu typu asemblacji o ID: " + str(assemb_id)) assemb = Assemb.objects.filter(id=assemb_id).values() try: assemb_ret = assemb[0] except IndexError: LOG.WARN("Nie istnieje typ asemblacji o ID: " + str(assemb_id)) return None LOG.INFO("Zakonzylem pobieranie obiektu typu asemblacji o ID: " + str(assemb_id)) return assemb_ret
def getScaffByContID(cont_id): LOG.INFO("Rozpoczynam pobieranie scaffoldu, na ktorym jest contig o ID: " + str(cont_id)) try: c = Contig.objects.get(id = int(cont_id)) except Contig.DoesNotExist: LOG.WARN("Brak contigu o ID: " + str(cont_id)) return None scaff_id = c.scaff_id #TODO: Funkcja musisz zwracac scaffold, do ktorego nalezy dany contig. Problem? Do ktorej ScaffoldPosition nalezy ten contig? LOG.DEBUG("Contig o ID: " + str(cont_id) + " znajduje sie na scaffoldzie o ID: " + str(scaff_id)) LOG.INFO("Zakonczylem pobieranie scaffoldu na ktorym jest contig o ID: " + str(cont_id)) return c.scaff_id
def getOrganismsByID(organism_id): LOG.INFO("Rozpoczynam pobieranie obiektu organizmu o ID: " + str(organism_id)) organism = Organism.objects.filter(id=organism_id).values() try: organism_ret = organism[0] except IndexError: LOG.WARN("Nie istnieje organizm o ID: " + str(organism_id)) return None LOG.INFO("Zakonczylem pobieranie obiektu organizmu o ID: " + str(organism_id)) return organism_ret
def getContigs(scaff_id): LOG.INFO("Rozpoczynam pobieranie contigow ze scaffoldu o ID: " + str(scaff_id)) contigs = Contig.objects.all().filter(scaff_id = str(scaff_id)) LOG.DEBUG("Ilosc contigow na scaffoldzie o ID: " + str(scaff_id) + " wynosi " + str(len(contigs))) conts_return = [] for cont in contigs: try: c = Contig.objects.all().get(id = cont.id) except Contig.DoesNotExist: LOG.WARN("Brak contigu o ID: " + str(cont.id)) return None cont_wrap = ContigWrap(c.id, c.scaff_id, c.order, c.start, c.end, c.sequence, c.length_bp) conts_return.append(cont_wrap) LOG.INFO("Zakonczylem pobieranie contigow ze scaffoldu o ID: " + str(scaff_id)) return conts_return
def getMarkersOnScaffold(scaff_id): LOG.INFO("Rozpoczynam pobieranie markerow ze scaffoldu o ID: " + str(scaff_id)) markers = Marker.objects.all().filter(scaff_id = str(scaff_id)) LOG.DEBUG("Ilosc markerow na scaffoldzie o ID: " + str(scaff_id) + " wynosi " + str(len(markers))) marks_return = [] for mark in markers: try: m = Marker.objects.all().get(name = mark.name) except Marker.DoesNotExist: LOG.WARN("Brak markera o nazwie: " + str(mark.name)) return None #TODO: Tutaj jezeli nie bedzie dzialalo bedzie trzeba zrobic jakiegos Wrapa marks_return.append(m) LOG.INFO("Zakonczylem pobieranie markerow ze scaffoldu o ID: " + str(scaff_id)) return marks_return
def deleteOrganism(org_id): LOG.INFO("Rozpoczynam usuwanie organizmu o ID: " + str(org_id)) try: o = Organism.objects.get(id=int(org_id)) except Organism.DoesNotExist: LOG.WARN("Brak organizmu o ID: " + str(org_id)) return None o.delete() LOG.DEBUG("Usuwam wszystkie chromosomy organizmu: " + str(org_id) + " wraz z podleglymi strukturami") # Usuniecie wszystkich chromosomow ze wszystkimi strukturami chrs = Chromosome.objects.filter(organism_id=int(org_id)) for chromosome in chrs: LOG.DEBUG("Usuwam chromosome: " + str(chromosome.id) + " z organizmu: " + str(org_id)) deleteChromosome(chromosome.id) LOG.DEBUG("Usuwam wszystkie typy asemblacji z organizmu: " + str(org_id)) # Usuniecie wszystkich typow asemblacji Assemb.objects.filter(organism_id=int(org_id)).delete() LOG.INFO("Zakonczylem usuwanie organizmu o ID: " + str(org_id)) return True
def updateAssembs(new_assembs, org_id): LOG.INFO( "Rozpoczynam uaktualnianie wszystkich typow asemblacji dla organizmu: " + str(org_id)) LOG.DEBUG("Nowe typy asemblacji: " + str(new_assembs)) new_assembs_tmp_dict = {} added_assembs = [] # DODANIE for new_ass in new_assembs: try: # Jezeli ID = -1 -> dodajemy if int(new_ass['ID']) == -1: LOG.DEBUG("Dodaje nowy typ asemblacji: " + str(new_ass['NAME'])) a = Assemb(name=new_ass['NAME'], description=new_ass['DESC'], organism_id=int(org_id)) a.save() new_ass['ID'] = str(a.id) added_assembs.append(new_ass['ID']) # Dodanie odpowiednich ChromosomeLength LOG.DEBUG("Dodaje odpowiednie wpisy w ChromosomeLength.") chromosomes = Chromosome.objects.all().filter( organism_id=int(org_id)) LOG.DEBUG("Wszystkie chromosomy organizmu: " + str(org_id) + ": " + str(chromosomes)) for chromosome_obj in chromosomes: LOG.DEBUG("Dodaje nowa dlugosc chromosomu " + str(chromosome_obj.id) + " dla typu asemblacji: " + str(new_ass['NAME'])) chr_len_new = ChromosomeLength(chr_id=chromosome_obj.id, assemb_id=a.id, length=0.0) chr_len_new.save() LOG.DEBUG( "Dodalem nowa dlugosc chromosomu dla typu asemblacji: " + str(new_ass['NAME']) + " --> " + str(chr_len_new.id)) # Jezeli nie -> dodajemy do new_assembs_tmp_dict, zeby ponizszy for byl wydajniejszy else: new_assembs_tmp_dict[int(new_ass['ID'])] = { 'NAME': new_ass['NAME'], 'DESC': new_ass['DESC'] } except Exception: LOG.WARN("Blad podczas dodawania nowych typow asemblacji.") return None # UAKTUALNIENIE / USUNIECIE assembs_db = Assemb.objects.filter(organism_id=int(org_id)) LOG.DEBUG("Typy asemblacji w bazie przed modyfikacja oraz usuwaniem: " + str(assembs_db)) try: for ass in assembs_db: # Jezeli istnieje w slowniku -> uaktualniamy name i desc if new_assembs_tmp_dict.has_key(int(ass.id)): LOG.DEBUG("Uaktualniam typ asemblacji: " + str(ass)) ass.name = new_assembs_tmp_dict[int(ass.id)]['NAME'] ass.description = new_assembs_tmp_dict[int(ass.id)]['DESC'] ass.save() # Jezeli nie ma w slowniku i w nowo dodanych -> usuwamy else: LOG.DEBUG("Probuje usunac typ asemblacji: " + str(ass)) if str(ass.id) not in added_assembs: LOG.DEBUG("Usuwam typ asemblacji: " + str(ass)) ass.delete() except ValueError: LOG.WARN( "Blad podczas dodawania nowych typow asemblacji (ValueError).") return None LOG.INFO("Zakonczylem uaktualnianie wszystkich typow asemblacji.") return new_assembs
def _searchSW(pattern, structs, match=2, mismatch=-1, gap_open=-3, gap_extend=-1, callback=None): # Sprawdzamy czy na pewno mamy do czynienia z lancuchem znakow if not isinstance(pattern, basestring): LOG.WARN("Wzorzec nie jest dozwolona sekwencja znakow!") return None pattern = str(pattern) if callback == None: callback = debug # Wynik results = [] # Tworzymy obiekt algorytmu LOG.INFO("Utworzenie obiektu algorytmu SW.") sw = calc.SW() if "S" in structs or "A" in structs: # 5 % callback(5, "Retrieving the scaffolds database...") LOG.INFO("Pobranie sekwencji scaffoldow z bazy danych.") # Scaffolds scaffs = Scaffold.objects.values('id', 'sequence') # 20 % callback(20, "Searching in scaffolds...") LOG.INFO("Uruchomienie algorytmu dla sekwencji scaffoldow.") scaffs_results = _searchMaxSW(callback, pattern, scaffs, sw, match, mismatch, gap_open, gap_extend, "Scaffold") results.extend(scaffs_results) LOG.DEBUG("Ilosc znalezionych scaffoldow: " + str(len(scaffs_results))) if "U" in structs or "A" in structs: # 40 % callback(40, "Retrieving the undefined scaffolds database...") LOG.INFO("Pobranie sekwencji niezdefiniowanych scaffoldow.") # Undefined Scaffolds udef_scaffs = UndefinedScaffold.objects.values('id', 'sequence') # 55 % callback(55, "Searching in undefined scaffolds...") LOG.INFO( "Uruchomienie algorytmu dla sekwencji niezdefiniowanych scaffoldow." ) udef_scaffs_results = _searchMaxSW(callback, pattern, udef_scaffs, sw, match, mismatch, gap_open, gap_extend, "Undefined scaffold") results.extend(udef_scaffs_results) LOG.DEBUG("Ilosc znalezionych niezdefiniowanych scaffoldow: " + str(len(udef_scaffs_results))) if "C" in structs or "A" in structs: # 75 % callback(75, "Retrieving the contigs database...") LOG.INFO("Pobranie sekwencji contigow.") # Contigs conts = Contig.objects.values('id', 'sequence') # 90 % callback(90, "Searching in contigs...") LOG.INFO("Uruchomienie algorytmu dla sekwencji contigow.") conts_results = _searchMaxSW(callback, pattern, conts, sw, match, mismatch, gap_open, gap_extend, "Contig") results.extend(conts_results) LOG.DEBUG("Ilosc znalezionych contigow: " + str(len(conts_results))) # 95 % callback(95, "Saving results...") return results
def _runBLAST_SW(pattern, w, t, c, cut_off, structs="A", callback=None): # Sprawdzamy czy na pewno mamy do czynienia z lancuchem znakow if not isinstance(pattern, basestring): LOG.WARN("Wzorzec nie jest dozwolona sekwencja znakow!") return None pattern = str(pattern) if callback == None: callback = debug # Tworzymy obiekt algorytmu BLAST LOG.INFO("Utworzenie obiektu algorytmu BLAST.") blast = calc.Blast(w, t, c) callback(5, "Preparing sequence...") LOG.INFO("Przygotowanie sekwencji.") res = blast.prepare(str(pattern)) if res == 0: LOG.WARN( "Parametr W (= " + str(w) + ") powinien byc nie wiekszy od dlugosci zadanej sekwencji (= " + str(len(pattern)) + ").") return ( False, "Parametr W (= " + str(w) + ") powinien byc nie wiekszy od dlugosci zadanej sekwencji (= " + str(len(pattern)) + ").") types = [] # Scaffolds if "S" in structs or "A" in structs: callback(10, "Retrieving the scaffolds database...") LOG.INFO("Pobranie sekwencji scaffolodow.") scaffs = Scaffold.objects.values('id', 'sequence') types.append((static.SEARCH_SCAFFOLDS, scaffs)) # Undefined Scaffolds if "U" in structs or "A" in structs: callback(11, "Retrieving the undefined scaffolds database...") LOG.INFO("Pobranie sekwencji niezdefiniowanych scaffolodow.") uscaffs = UndefinedScaffold.objects.values('id', 'sequence') types.append((static.SEARCH_UDEF_SCAFFOLDS, uscaffs)) # Contigs if "C" in structs or "A" in structs: callback(12, "Retrieving the contigs database...") LOG.INFO("Pobranie sekwencji contigow.") conts = Contig.objects.values('id', 'sequence') types.append((static.SEARCH_CONTIGS, conts)) callback(15, "Adding sequences to algorithm...") LOG.INFO("Dodanie sekwencji do algorytmu.") id_type = {} #TODO: TESTOWO OGRANICZONE!!! for (type_, seqs) in types: for seq in seqs: #[:10]: blast.addSequence(str(seq['id']), str(seq['sequence'])) id_type[str(seq['id'])] = str(type_) callback(30, "Searching in database...") LOG.INFO("Przeszukanie sekwencji.") res = blast.search() if res == 0: LOG.WARN( "Zbyt wysoka wartosc parametru W (= " + str(w) + "). Nie mozna odnalezc zadnego fragmentu poszukiwanej sekwecji.") return ( False, "Zbyt wysoka wartosc parametru W (= " + str(w) + "). Nie mozna odnalezc zadnego fragmentu poszukiwanego sekwecji.") callback(50, "Limiting the set of sequences...") LOG.INFO("Zmniejszenie liczby elementow najistotniejszych.") res = blast.estimate() if res == 0: LOG.WARN("Zbyt wysoka wartosc parametru T (= " + str(t) + "). Powinien zawierac sie w zakresie od " + str(blast.getMinRate()) + " do " + str(blast.getMaxRate()) + ", srednia wartosc rate wynosi " + str(blast.getAvgRate())) return (False, "Zbyt wysoka wartosc parametru T (= " + str(t) + "). Powinien zawierac sie w zakresie od " + str(blast.getMinRate()) + " do " + str(blast.getMaxRate()) + ", srednia wartosc rate wynosi " + str(blast.getAvgRate())) callback(70, "Extending keywords...") LOG.INFO("Rozszerzenie slow kluczowych.") res = blast.extend() callback(75, "Calculating additional parameters...") LOG.INFO("Obliczenie dodatkowych parametrow.") res = blast.evaluate() callback(79, "Retreving results...") LOG.INFO("Pobranie " + str(cut_off) + " najlepszych sekwencji.") aligns = blast.getAligns(cut_off) results_sw = [] LOG.INFO("Pogrupowanie wynikow BLAST. Pobranych rezultatow: " + str(len(aligns))) # Uruchomienie algorytmu SW z domyslnymi wartosciami parametrow # Tworzymy obiekt algorytmu SW LOG.INFO("Utworzenie obiektu algorytmu SW.") callback( 80, "Starting Smith-Waterman algorithm for top " + str(cut_off) + " sequences...") sw = calc.SW() for i, align in enumerate(aligns): seq_id = align.getSequenceId() try: seq_type = id_type[str(seq_id)] except KeyError: seq_type = "Unknown" obj = None try: if seq_type == static.SEARCH_SCAFFOLDS: obj = Scaffold.objects.get(id=str(seq_id)) elif seq_type == static.SEARCH_UDEF_SCAFFOLDS: obj = UndefinedScaffold.objects.get(id=int(seq_id)) elif seq_type == static.SEARCH_CONTIGS: obj = Contig.objects.get(id=int(seq_id)) else: LOG.WARN("Blad wykonania programu! Nie znaleziono typu " + str(seq_type)) return (False, "Blad wykonania programu!") except Scaffold.DoesNotExist or UndefinedScaffold.DoesNotExist or Contig.DoesNotExist: LOG.WARN("Blad wykonania programu! Nie znaleziono sekwencji " + str(seq_id) + " w typie " + str(seq_type)) return (False, "Blad wykonania programu!") # Uruchomienie algorytmu LOG.INFO( "Uruchomienie algorytmu w wersji fastComputeWithStringsResult") similarity = sw.fastComputeWithStringsResult(2, -1, -3, -1, str(obj.sequence), pattern) result = {} result['TYPE'] = str(seq_type) result['ID'] = str(obj.id) result['SCORE'] = str(similarity.getValue()) seq_after = similarity.getText() pat_after = similarity.getPattern() align_len = len(seq_after) gaps = 0 same = 0 for i, l in enumerate(seq_after): if l == '-': # dziurka gaps += 1 elif l == pat_after[i]: # takie same same += 1 result['GAPS'] = str(gaps) result['IDENTITY'] = str(float(same) / float(align_len)) result['LENGTH'] = align_len seq_end_index = similarity.getPositionJ() seq_start_index = seq_end_index - len(str(seq_after).replace("-", "")) result['SEQ_START_INDEX'] = seq_start_index result['SEQ_END_INDEX'] = seq_end_index results_sw.append(result) callback(95, "Sorting results...") LOG.INFO("Posortowanie wynikow.") results_sw = sorted(results_sw, key=lambda res: res['IDENTITY'], reverse=True) return (True, results_sw)
def _runBLAST(pattern, w, t, c, cut_off, structs="A", callback=None): # Sprawdzamy czy na pewno mamy do czynienia z lancuchem znakow if not isinstance(pattern, basestring): LOG.WARN("Wzorzec nie jest dozwolona sekwencja znakow!") return None pattern = str(pattern) if callback == None: callback = debug # Wynik results = [] start = time.time() # Tworzymy obiekt algorytmu LOG.INFO("Utworzenie obiektu algorytmu BLAST.") blast = calc.Blast(w, t, c) callback(5, "Preparing sequence...") LOG.INFO("Przygotowanie sekwencji.") res = blast.prepare(str(pattern)) if res == 0: LOG.WARN( "Parametr W (= " + str(w) + ") powinien byc nie wiekszy od dlugosci zadanej sekwencji (= " + str(len(pattern)) + ").") return ( False, "Parametr W (= " + str(w) + ") powinien byc nie wiekszy od dlugosci zadanej sekwencji (= " + str(len(pattern)) + ").") types = [] # Scaffolds if "S" in structs or "A" in structs: callback(10, "Retrieving the scaffolds database...") LOG.INFO("Pobranie sekwencji scaffolodow.") scaffs = Scaffold.objects.values('id', 'sequence') types.append(("Scaffold", scaffs)) # Undefined Scaffolds if "U" in structs or "A" in structs: callback(11, "Retrieving the undefined scaffolds database...") LOG.INFO("Pobranie sekwencji niezdefiniowanych scaffolodow.") uscaffs = UndefinedScaffold.objects.values('id', 'sequence') types.append(("Undefined scaffold", uscaffs)) # Contigs if "C" in structs or "A" in structs: callback(12, "Retrieving the contigs database...") LOG.INFO("Pobranie sekwencji contigow.") conts = Contig.objects.values('id', 'sequence') types.append(("Contig", conts)) callback(15, "Adding sequences to algorithm...") LOG.INFO("Dodanie sekwencji do algorytmu.") id_type = {} #TODO: TESTOWO OGRANICZONE!!! for (type_, seqs) in types: for seq in seqs[:10]: blast.addSequence(str(seq['id']), str(seq['sequence'])) id_type[str(seq['id'])] = str(type_) callback(50, "Searching in database...") LOG.INFO("Przeszukanie sekwencji.") res = blast.search() if res == 0: LOG.WARN( "Zbyt wysoka wartosc parametru W (= " + str(w) + "). Nie mozna odnalezc zadnego fragmentu poszukiwanej sekwecji.") return ( False, "Zbyt wysoka wartosc parametru W (= " + str(w) + "). Nie mozna odnalezc zadnego fragmentu poszukiwanego sekwecji.") callback(70, "Limiting the set of sequences...") LOG.INFO("Zmniejszenie liczby elementow najistotniejszych.") res = blast.estimate() if res == 0: LOG.WARN("Zbyt wysoka wartosc parametru T (= " + str(t) + "). Powinien zawierac sie w zakresie od " + str(blast.getMinRate()) + " do " + str(blast.getMaxRate()) + ", srednia wartosc rate wynosi " + str(blast.getAvgRate())) return (False, "Zbyt wysoka wartosc parametru T (= " + str(t) + "). Powinien zawierac sie w zakresie od " + str(blast.getMinRate()) + " do " + str(blast.getMaxRate()) + ", srednia wartosc rate wynosi " + str(blast.getAvgRate())) callback(90, "Extending keywords...") LOG.INFO("Rozszerzenie slow kluczowych.") res = blast.extend() callback(95, "Calculating additional parameters...") LOG.INFO("Obliczenie dodatkowych parametrow.") res = blast.evaluate() callback(99, "Retreving results...") LOG.INFO("Pobranie " + str(cut_off) + " najlepszych sekwencji.") aligns = blast.getAligns(cut_off) LOG.INFO("Pogrupowanie wynikow. Pobranych rezultatow: " + str(len(aligns))) aligns_len = len(aligns) # Zebranie wynikow for i, align in enumerate(aligns): same = align.getSame() align_len = align.getAlignLength() seq_id = align.getSequenceId() result = {} try: result['TYPE'] = id_type[str(seq_id)] except KeyError: result['TYPE'] = "Unknown" result['ID'] = str(seq_id) result['SCORE'] = str(align.getScore()) result['IDENTITY'] = str((float(same) / float(align_len) * 100.00)) result['GAPS'] = str(align.getGaps()) result['LENGTH'] = str(align_len) result['SEQ_START_INDEX'] = str(align.getSeqStart()) result['SEQ_END_INDEX'] = str(align.getSeqEnd()) results.append(result) LOG.DEBUG("Zapisalem wynik " + str(i + 1) + "/" + str(aligns_len) + ":\n" + str(result)) LOG.INFO("Zakonczylem grupowanie wynikow. Rezultatow: " + str(len(results))) end = time.time() LOG.DEBUG("Czas dzialania algorytmu BLAST dla sekwencji o dlugosci " + str(len(str(pattern))) + ": " + str(end - start) + "s.") return (True, results)
def findKMP(callback, pattern, structs): # Sprawdzamy czy na pewno mamy do czynienia z lancuchem znakow if not isinstance(pattern, basestring): LOG.WARN("Wzorzec nie jest dozwolona sekwencja znakow!") return None pattern = str(pattern) # Wynik results = [] # Tworzymy obiekt algorytmu LOG.INFO("Utowrzenie obiektu algorytmu KMP.") kmp = calc.KMP() # Obliczenie tablicy pomocniczej LOG.INFO("Obliczenie tablicy pomocniczej.") status = kmp.calculateTable(pattern) if "S" in structs or "A" in structs: # 5 % callback(5, "Retrieving the scaffolds database...") LOG.INFO("Pobranie sekwencji scaffoldow.") # Scaffolds scaffs = Scaffold.objects.values('id', 'sequence') # 20 % callback(20, "Searching in scaffolds...") LOG.INFO("Uruchomienie algorytmu dla sekwencji scaffoldow.") scaffs_results = _findKMP(callback, pattern, scaffs, kmp, "Scaffold") results.extend(scaffs_results) LOG.DEBUG("Ilosc znalezionych scaffoldow: " + str(len(scaffs_results))) if "U" in structs or "A" in structs: # 40 % callback(40, "Retrieving the undefined scaffolds database...") LOG.INFO("Pobranie sekwencji niezdefiniowanych scaffolodow.") # Undefined Scaffolds udef_scaffs = UndefinedScaffold.objects.values('id', 'sequence') # 55 % callback(55, "Searching in undefined scaffolds...") LOG.INFO( "Uruchomienie algorytmu dla sekwencji niezdefiniowanych scaffoldow." ) udef_scaffs_results = _findKMP(callback, pattern, udef_scaffs, kmp, "Undefined scaffold") results.extend(udef_scaffs_results) LOG.DEBUG("Ilosc znalezionych niezdefiniowanych scaffoldow: " + str(len(udef_scaffs_results))) if "C" in structs or "A" in structs: # 75 % callback(75, "Retrieving the contigs database...") LOG.INFO("Pobranie sekwencji contigow.") # Contigs conts = Contig.objects.values('id', 'sequence') # 90 % callback(90, "Searching in contigs...") LOG.INFO("Uruchomienie algorytmu dla sekwencji contigow.") conts_results = _findKMP(callback, pattern, conts, kmp, "Contig") results.extend(conts_results) LOG.DEBUG("Ilosc znalezionych contigow: " + str(len(conts_results))) # 95 % callback(95, "Saving results...") return (True, results)