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 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 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 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 searchProgressSW(pattern,
match=2,
mismatch=-1,
gap_open=-1,
gap_extend=-1,
structs="A"):
LOG.INFO(
"Rozpoczynam poszukiwanie podobnej sekwencji algorytmem SW.\nMATCH: " +
str(match) + "\nMISMATCH: " + str(mismatch) + "\nGAP OPEN: " +
str(gap_open) + "\nGAP EXTEND: " + str(gap_extend) + "\nWzorzec: " +
str(pattern) + "\nPoszukuje: " + str(structs))
rm = RemoteManager()
params = {
"pattern": pattern,
"structs": structs,
"match": match,
"mismatch": mismatch,
"gap_open": gap_open,
"gap_extend": gap_extend
}
tid = rm.run(searchSW, params)
LOG.DEBUG("Poszukiwanie podobnej sekwencji algorytmem SW. Numer watku: " +
str(tid))
return tid
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 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 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 buildMarkerContigTree(cont_id):
LOG.INFO("Rozpoczynam budowanie drzewa przedzialowego markerow dla contigu 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)))
markers_to_tree = []
for marker in markers:
marker_interval = MarkerInterval(marker.name, marker.contig_start, marker.contig_end, -1)
markers_to_tree.append(marker_interval)
if len(markers) != 0:
# Zapamietanie obiektu drzewa przedzialowego
MarkersContigTreeObject.interval_tree = MarkerIntervalTree(markers_to_tree)
LOG.INFO("Zakonczylem budowanie drzewa przedzialowego markerow dla contigu o ID:" + str(cont_id))
return 1
else:
LOG.INFO("Nie znaleziono markerow dla contigu o ID:" + str(cont_id))
return 0
def buildContigTree(scaff_id):
LOG.INFO("Rozpoczynam budowanie drzewa przedzialowego contigow dla 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)))
contigs_to_tree = []
for contig in contigs:
contig_interval = ContigInterval(contig.id, contig.start, contig.end, -1)
contigs_to_tree.append(contig_interval)
if len(contigs) != 0:
# Zapamietanie obiektu drzewa przedzialowego
ContigsTreeObject.interval_tree = ContigIntervalTree(contigs_to_tree)
LOG.INFO("Zakonczylem budowanie drzewa przedzialowego contigow dla scaffoldu o ID:" + str(scaff_id))
return 1
else:
LOG.INFO("Nie znaleziono contigow dla scaffoldu o ID: " + str(scaff_id))
return 0
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 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 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 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 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 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 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 _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 _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 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
