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