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 getAssembsDictFromOrganism(organism_id): LOG.INFO( "Rozpoczynam pobieranie wszystkich typow asemblacji - wersja dict z organizmu: " + str(organism_id)) assembs = [] assembs_db = getAssembsFromOrganism(organism_id) for ass in assembs_db: assemb = {} assemb['ID'] = ass['id'] assemb['NAME'] = ass['name'] assemb['DESC'] = ass['description'] scaff_count = Scaffold.objects.filter(assemb_type=ass['id']).count() assemb['SCAFF_COUNT'] = scaff_count assembs.append(assemb) LOG.INFO( "Zakonczylem pobieranie wszystkich typow asemblacji - wersja dict z organizmu: " + str(organism_id)) return assembs
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 _searchMaxSW(callback, pattern, objects, sw, match, mismatch, gap_open, gap_extend, struct_name): results = [] ### !!!!!!!!!!!!!!!!!!!!!!!! objects = objects[6:7] ### !!!!!!!!!!!!!!!!!!!!!!!! for i, obj in enumerate(objects): # Uruchomienie algorytmu LOG.INFO( "Uruchomienie algorytmu w wersji fastComputeWithStringsResult") similarity = sw.fastComputeWithStringsResult(match, mismatch, gap_open, gap_extend, str(obj['sequence']), pattern) result = {} result['TYPE'] = str(struct_name) 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.append(result) LOG.INFO("Posortowanie wynikow.") results = sorted(results, key=lambda res: res[0], reverse=True) return results
def getContigsDict(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 i, cont in enumerate(contigs): cont_dict = {} cont_dict['LP'] = i + 1 cont_dict['ID'] = cont.id cont_dict['SCAFF_ID'] = cont.scaff_id cont_dict['START_INDEX'] = cont.start cont_dict['END_INDEX'] = cont.end cont_dict['LENGTH'] = cont.length_bp conts_return.append(cont_dict) LOG.INFO("Zakonczylem pobieranie contigow ze scaffoldu o ID: " + str(scaff_id)) return conts_return
def findProgressKMP(pattern, structs="A"): LOG.INFO( "Rozpoczynam poszukiwanie podobnej sekwencji algorytmem KMP.\nWzorzec: " + str(pattern) + ". Poszukuje: " + str(structs)) rm = RemoteManager() params = {"pattern": pattern, "structs": structs} tid = rm.run(findKMP, params) LOG.DEBUG("Poszukiwanie podobnej sekwencji algorytmem KMP. Numer watku: " + str(tid)) return tid
def getMarkersDictOnScaff(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 i, mark in enumerate(markers): mark_dict = {} mark_dict['LP'] = i + 1 mark_dict['NAME'] = mark.name mark_dict['CHR_ID'] = mark.chr_id mark_dict['POS_CM'] = mark.pos_cm mark_dict['SCAFF_ID'] = mark.scaff_id mark_dict['START_INDEX'] = mark.scaffold_start mark_dict['END_INDEX'] = mark.scaffold_end marks_return.append(mark_dict) LOG.INFO("Zakonczylem pobieranie markerow ze scaffoldu o ID: " + str(scaff_id)) return marks_return
def getMarkersDictOnCont(cont_id): LOG.INFO("Rozpoczynam pobieranie markerow z contiga o ID: " + str(cont_id)) markers = Marker.objects.all().filter(cont_id = int(cont_id)) LOG.DEBUG("Ilosc markerow na contigu o ID: " + str(cont_id) + " wynosi " + str(len(markers))) marks_return = [] for i, mark in enumerate(markers): mark_dict = {} mark_dict['LP'] = i + 1 mark_dict['NAME'] = mark.name mark_dict['CHR_ID'] = mark.chr_id mark_dict['POS_CM'] = mark.pos_cm mark_dict['CONT_ID'] = mark.cont_id mark_dict['START_INDEX'] = mark.contig_start mark_dict['END_INDEX'] = mark.contig_end marks_return.append(mark_dict) LOG.INFO("Zakonczylem pobieranie markerow z contiga o ID: " + str(cont_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 findProgressBLAST_SW(pattern, w, t, c, cut_off, structs="A"): LOG.INFO( "Rozpoczynam poszukiwanie podobnej sekwencji algorytmem BLAST.\nW: " + str(w) + "\nT: " + str(t) + "\nC: " + str(c) + "\nCUT OFF: " + str(cut_off) + "\nWzorzec: " + str(pattern) + "\nPoszukuje: " + str(structs)) rm = RemoteManager() params = { "pattern": pattern, "w": w, "t": t, "c": c, "cut_off": cut_off, "structs": structs } tid = rm.run(runBLAST_SW, params) LOG.DEBUG( "Poszukiwanie podobnej sekwencji algorytmem BLAST. Numer watku: " + str(tid)) return tid
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 getAssembs(): LOG.INFO("Rozpoczynam pobieranie wszystkich typow asemblacji.") assembs = Assemb.objects.all().values() LOG.INFO("Zakonczylem pobieranie wszystkich typow asemblacji: " + str(assembs)) return assembs
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)
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 getOrganisms(): LOG.INFO("Rozpoczynam pobieranie wszystkich organizmow.") organisms = Organism.objects.all().values() LOG.INFO("Zakonczylem pobieranie wszystkich organizmow.") return organisms