19
|
1 """
|
|
2 * Galaxy Version
|
|
3
|
|
4 * Copyright 2019 University of Liverpool
|
|
5 * Author John Heap, Computational Biology Facility, UoL
|
|
6 * Based on original scripts of Sara Silva Silva Pereira, Institute of Infection and Global Health, UoL
|
|
7 *
|
|
8 * Licensed under the Apache License, Version 2.0 (the "License");
|
|
9 * you may not use this file except in compliance with the License.
|
|
10 * You may obtain a copy of the License at
|
|
11 *
|
|
12 * http://www.apache.org/licenses/LICENSE-2.0
|
|
13 *
|
|
14 * Unless required by applicable law or agreed to in writing, software
|
|
15 * distributed under the License is distributed on an "AS IS" BASIS,
|
|
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
17 * See the License for the specific language governing permissions and
|
|
18 * limitations under the License.
|
|
19 *
|
|
20 """
|
|
21
|
|
22
|
|
23 import subprocess
|
|
24 import pandas as pd
|
|
25 import re
|
|
26 import os
|
|
27 import sys
|
|
28 import shutil
|
|
29 # import matplotlib as mpl
|
|
30 # mpl.use('Agg')
|
|
31 import matplotlib.pyplot as plt
|
|
32 import numpy as np
|
|
33
|
|
34
|
|
35
|
|
36
|
|
37 # copies the user provided Fasta file to data/reference/file/file.fasta
|
|
38 def uploadUserReferenceFastq(refFastq):
|
|
39 refBase = os.path.basename(refFastq)
|
|
40 ref = os.path.splitext(refBase)[0] # 'mydata/test.fasta' -> 'test'
|
|
41 dir_path = os.path.dirname(os.path.realpath(__file__)) # directory of this file
|
|
42 refDir = dir_path + "/data/Reference/" + ref #propose putting file in '/data/reference/ref/
|
|
43 if not os.path.isdir(refDir): # if directory data/Reference/ref doesn't exist
|
|
44 os.mkdir(refDir)
|
|
45 refPath = refDir+"/"
|
|
46 shutil.copy(refFastq, refPath + refBase) #copy reference file into the directory
|
|
47 argString = "bowtie2-build " + refPath + refBase+" "+refPath+ref
|
|
48 print("Building the bowtie2 reference files.")
|
|
49 subprocess.call(argString, shell=True)
|
|
50 return
|
|
51
|
|
52 def transcriptMapping(inputname, refFastq, forwardFN, reverseFN):
|
|
53 # where is our Reference data?
|
|
54 refBase = os.path.basename(refFastq)
|
|
55 ref = os.path.splitext(refBase)[0]
|
|
56 dir_path = os.path.dirname(os.path.realpath(__file__))
|
|
57 refDir = dir_path + "/data/Reference/" + ref + "/"
|
|
58 refName = refDir + ref
|
|
59 # now have reference file so we can proceed with the transcript mapping via bowtie2
|
|
60 argString = "bowtie2 -x "+refName+" -1 "+forwardFN+" -2 "+reverseFN+" -S "+inputname+".sam"
|
|
61 print(argString)
|
|
62 subprocess.call(argString, shell=True) #outputs a name.sam file
|
|
63 return
|
|
64
|
|
65
|
|
66
|
|
67 def processSamFiles(inputname):
|
|
68 cur_path = os.getcwd()
|
|
69 samName = cur_path+"/"+inputname
|
|
70 argString = "samtools view -bS "+inputname+".sam > "+samName+".bam"
|
|
71 print(argString)
|
|
72 subprocess.call(argString, shell=True)
|
|
73
|
|
74 argString = "samtools sort "+samName+".bam -o "+samName+".sorted"
|
|
75 print("argstring = "+argString)
|
|
76 subprocess.call(argString, shell=True)
|
|
77
|
|
78 argString = "samtools index "+samName+".sorted "+samName+".sorted.bai"
|
|
79 print("argstring = " + argString)
|
|
80 subprocess.call(argString, shell=True)
|
|
81 return #we have saved out the relevent name.bam, name.sorted and name.sorted.bai files
|
|
82
|
|
83 # we will not have the .gtf file so call cufflinks without -G option
|
|
84 def transcriptAbundance(inputname):
|
|
85 argString = "cufflinks -o "+inputname+".cuff -u -p 8 "+inputname+".sorted"
|
21
|
86 subprocess.call(argString, shell=True)
|
19
|
87 os.remove(inputname+".sorted") #remove name.sorted
|
|
88 os.remove(inputname+".sorted.bai")
|
|
89 os.remove(inputname+".bam")
|
|
90 return
|
|
91
|
|
92 def transcriptsForBlast(name, refFastq):
|
|
93 # quick and dirty just to see.
|
|
94 refBase = os.path.basename(refFastq)
|
|
95 ref = os.path.splitext(refBase)[0] # 'mydata/test.fasta' -> 'test'
|
|
96 dir_path = os.path.dirname(os.path.realpath(__file__)) # directory of this file
|
|
97 refPath = dir_path + "/data/Reference/" + ref + "/" + refBase # eg refPath = data/Reference/Trinity/Trinity.fasta
|
|
98 # used for dirty # refPath = 'Trinity.fasta' # dirty one
|
26
|
99 cur_path = os.getcwd()
|
|
100 track_df = pd.read_csv(cur_path+'/' + name + '.cuff/genes.fpkm_tracking', sep='\t')
|
19
|
101 names = track_df['locus']
|
|
102 # print(len(names))
|
|
103 # print(names[:5])
|
|
104
|
|
105 nlist = []
|
|
106 for n in range(0,len(names)):
|
|
107 i = names[n].find(':')
|
|
108 nlist.append(names[n][:i])
|
|
109 nameset = set(nlist) #get unique.
|
|
110 with open(refPath, 'r') as myRef:
|
|
111 refData = myRef.read()
|
|
112 refData= refData+'\n>'
|
|
113
|
|
114 with open(name + '_for_blast.fa', 'w') as outfile:
|
|
115 for trans_id in nameset:
|
|
116 namepos = refData.find(trans_id)
|
|
117 endpos = refData.find('>', namepos)
|
|
118 outfile.write('>'+refData[namepos:endpos])
|
|
119
|
|
120 pass
|
|
121
|
|
122 def blastContigs(test_name,html_resource, database):
|
|
123 db_path = database
|
25
|
124 #argString = "makeblastdb - in " + db_path
|
|
125 #subprocess.call(argString, shell=True)
|
|
126
|
|
127 argString = "blastx -db " + db_path + " -query "+test_name+"_for_blast.fa -outfmt 10 -out "+test_name+"_blast.txt"
|
19
|
128 print(argString)
|
|
129 returncode = subprocess.call(argString, shell=True)
|
|
130 if returncode != 0:
|
|
131 return "Error in blastall"
|
|
132 blast_df = pd.read_csv(""+test_name+"_blast.txt")
|
|
133 blast_df.columns = ['qaccver', 'saccver', 'pident', 'length', 'mismatch', 'gapopen', 'qstart', 'qend', 'sstart', 'send', 'evalue','bitscore']
|
|
134 blastResult_df = blast_df[(blast_df['pident']>=70) & (blast_df['length'] > 100) & (blast_df['evalue'] <=0.001) ]
|
|
135 blastResult_df = blastResult_df[['qaccver', 'saccver', 'pident', 'evalue', 'bitscore']] #query accession.version, subject accession.version, Percentage of identical matches
|
|
136 # need to allocate the transcripts (if allocated more than once to the phylotype with least error.
|
|
137 transcripts = blastResult_df['qaccver']
|
|
138 b_df = pd.DataFrame(columns=['qaccver', 'saccver', 'pident', 'evalue', 'bitscore'])
|
|
139 transSet = set(transcripts)
|
|
140 for t in transSet:
|
|
141 temp_df = blastResult_df[(blastResult_df['qaccver'] == t)]
|
|
142 # get one with smallest error value
|
|
143 #print(t + ":")
|
|
144 #print(temp_df)
|
|
145 temp_df = temp_df.sort_values(by=['evalue'])
|
|
146 b_df = b_df.append(temp_df.iloc[[0]])
|
|
147
|
|
148 b_df.sort_values(by=['qaccver'])
|
|
149 b_df.to_csv(test_name + '_transcript.csv')
|
28
|
150 b_df.to_csv(html_resource+'/'+test_name + '_transcript.csv')
|
|
151
|
19
|
152 return b_df
|
|
153
|
|
154
|
|
155 def createMultiHTML(tdict,composite_df):
|
|
156 labelList = composite_df.columns.tolist()
|
|
157 htmlString = r"<html><title>T.vivax VAP (Transcriptomic Pathway(</title><body><div style='text-align:center'><h2><i>Trypanosoma vivax</i> Variant Antigen Profile</h2><h3>"
|
|
158 htmlString += r"Sample name: "+tdict['name']
|
|
159 htmlString += r"<br>Transcriptomic Analysis</h3></p>"
|
|
160 htmlString += "<p style = 'margin-left:20%; margin-right:20%'>Legend: " \
|
|
161 "Variant Antigen Profile of a <i>Trypanosoma vivax</i> transcriptomes. " \
|
|
162 "Weighted Frequency reflects Phylotype abundance and is expressed as " \
|
|
163 "phylotype frequencies adjusted for the combined transcript abundance. " \
|
|
164 "Data was produced with VAPPER-Variant Antigen Profiler " \
|
|
165 "(Silva Pereira et al., 2019).</p> "
|
|
166 htmlString += r"<style> table, th, tr, td {border: 1px solid black; border-collapse: collapse;}</style>"
|
|
167
|
|
168 header = r"<table style='width:50%;margin-left:25%;text-align:center'><tr><th>Phylotype</th>"
|
|
169 wLists = []
|
|
170
|
|
171 for j in range(1,len(labelList)):
|
|
172 wLists.append(composite_df[labelList[j]])
|
|
173 header += r"<th>" + str(labelList[j]) + "</th>"
|
|
174
|
|
175 htmlString += "</tr>\n" + header
|
|
176 tabString = ""
|
|
177 phyList = composite_df['Phylotype']
|
|
178
|
|
179
|
|
180
|
|
181 for i in range(0, len(composite_df)):
|
|
182 tabString += "<tr><td>" + str(phyList[i]) + "</td>"
|
|
183 for j in range(0,len(labelList)-1):
|
|
184 #print(j)
|
|
185 f = format(wLists[j][i], '.4f')
|
|
186 tabString += "<td>" + str(f) + "</td>"
|
|
187 tabString += "</tr>\n"
|
|
188
|
|
189 htmlString += tabString + "</table><br><br><br><br><br>"
|
|
190 htmlString += r"<h3>Weighted Relative Frequencies of Detected Phylotypes.</h3>"
|
|
191 imgString = r"<img src = '"+ tdict['name']+"_phylotypes.png' alt='Bar chart of phylotype variation' style='max-width:100%'><br><br>"
|
|
192 htmlString += imgString
|
|
193
|
|
194 with open(tdict['html_file'], "w") as htmlfile:
|
|
195 htmlfile.write(htmlString)
|
|
196
|
|
197
|
|
198 def createHTML(tdict,sum_df):
|
|
199 #assumes imgs are heatmap.png, dheatmap.png, vapPCA.png and already in htmlresource
|
|
200 htmlString = r"<html><title>T.vivax VAP (Transcriptomic Pathway(</title><body><div style='text-align:center'><h2><i>Trypanosoma vivax</i> Variant Antigen Profile</h2><h3>"
|
|
201 htmlString += r"Sample name: "+tdict['name']
|
|
202 htmlString += r"<br>Transcriptomic Analysis</h3></p>"
|
|
203 htmlString += "<p style = 'margin-left:20%; margin-right:20%'>Legend: " \
|
|
204 "Variant Antigen Profile of a <i>Trypanosoma vivax</i> transcriptome. " \
|
|
205 "Weighted Frequency reflects Phylotype abundance and is expressed as " \
|
|
206 "phylotype frequencies adjusted for the combined transcript abundance. " \
|
|
207 "Data was produced with VAPPER-Variant Antigen Profiler " \
|
|
208 "(Silva Pereira et al., 2019).</p> "
|
|
209 htmlString += r"<style> table, th, tr, td {border: 1px solid black; border-collapse: collapse;}</style>"
|
|
210
|
|
211 htmlString += r"<table style='width:50%;table-layout: auto; margin-left:25%;text-align:center'><tr><th>Phylotype</th>" \
|
|
212 r"<th>Combined FPKM</th><th>Weighted Frequency</th></tr>"
|
|
213 tabString = ""
|
|
214 # flush out table with correct values
|
|
215 phySeries = sum_df['Phylotype']
|
|
216 # sacSeries = sum_df['saccver']
|
|
217 fSeries = sum_df['FPKM']
|
|
218 total = fSeries.sum()
|
|
219 # print("Total="+str(total))
|
|
220 for i in range(0, len(sum_df)):
|
|
221 # print(phySeries[i])
|
|
222 f = format(fSeries[i], '.2f')
|
|
223 w = format(fSeries[i]/total, '.2f')
|
|
224
|
|
225 #w = format(weightList[i], '.4f')
|
|
226
|
|
227 tabString += "<tr><td>" + str(phySeries[i]) + "</td><td>" + str(f) + "</td><td>"+str(w)+"</tr>"
|
|
228 htmlString += tabString + "</table><br><br><br><br><br>"
|
|
229 htmlString += r"<h3>Weighted Relative Frequencies of Detected Phylotypes.</h3>"
|
|
230 imgString = r"<img src = '"+ tdict['name']+"_phylotypes.png' alt='Bar chart of phylotype variation' style='max-width:100%'><br><br>"
|
|
231 htmlString += imgString
|
|
232
|
29
|
233 with open(tdict['html_file'], "w") as htmlfile:
|
19
|
234 htmlfile.write(htmlString)
|
|
235
|
|
236
|
|
237
|
|
238 def getPhyloNumber(sac):
|
|
239 i = sac.find('_')
|
|
240 return int(sac[1:i])
|
|
241
|
|
242 def combineFPMK(tdict):
|
27
|
243 # dir_path = os.path.dirname(os.path.realpath(__file__))+'/'
|
|
244 cur_path = os.getcwd()+'/'
|
|
245 fpkm_df = pd.read_csv(cur_path+tdict['name']+'.cuff/genes.fpkm_tracking', sep='\t')
|
19
|
246
|
|
247 #fpkm_df = pd.read_csv('genes.fpkm_tracking',sep='\t')
|
|
248 #print(fpkm_df.head())
|
|
249 fpkm_df['locus'] = fpkm_df['locus'].apply(lambda names: names[:names.find(':')])
|
|
250 #print(fpkm_df.head())
|
21
|
251
|
27
|
252 reducedBlast_df = pd.read_csv(cur_path + tdict['name']+'_transcript.csv')
|
19
|
253 # reducedBlast_df = pd.read_csv('TrinityVT_transcript.csv')
|
|
254 saccverSet = set(reducedBlast_df['saccver'])
|
|
255 saccverList = list(saccverSet)
|
|
256 saccverList.sort()
|
|
257 # print(saccverList[:5])
|
|
258 new_df = pd.DataFrame(columns=['qaccver','saccver','FPKM'])
|
|
259 for sv in saccverList:
|
|
260 #print(sv)
|
|
261 temp_df = reducedBlast_df[reducedBlast_df['saccver'] == sv]
|
|
262 qList = list(temp_df['qaccver'])
|
|
263 for q in qList:
|
|
264 f_df = fpkm_df[(fpkm_df['locus'] == q)]
|
|
265 if len(f_df) > 1:
|
|
266 print('WARNING MULTIPLE FPKM')
|
|
267 new_fpkm=list(f_df['FPKM'])
|
|
268 f = (new_fpkm[0])
|
|
269 # print(f)
|
|
270 new_df = new_df.append({'qaccver': q, 'saccver': sv, 'FPKM': f}, ignore_index=True)
|
|
271 FPKMsum_df = new_df.groupby('saccver')['FPKM'].sum().reset_index()
|
|
272
|
|
273 FPKMsum_df['Phylotype'] = FPKMsum_df.apply(lambda row: getPhyloNumber(row['saccver']), axis=1)
|
|
274 FPKMsum_df = FPKMsum_df.sort_values(by=['Phylotype'])
|
|
275 FPKMsum_df = FPKMsum_df.reset_index(drop=True)
|
|
276
|
|
277 # print(FPKMsum_df)
|
|
278 FPKMsum_df.to_csv('FPKM_sum.csv')
|
|
279 FPKMsum2_df = FPKMsum_df.groupby('Phylotype')['FPKM'].sum().reset_index()
|
|
280 FPKMsum2_df = FPKMsum2_df.sort_values(by=['Phylotype'])
|
|
281
|
|
282 # print(FPKMsum2_df)
|
|
283 FPKMsum2_df.to_csv('FPKM_sum2.csv') # in case more than one entry for a particular phylotype
|
28
|
284 htmlres = tdict['html_resource']
|
|
285 FPKMsum2_df.to_csv(htmlres+'/FPKM_sum2.csv') # in case more than one entry for a particular phylotype
|
|
286
|
19
|
287 return FPKMsum_df, FPKMsum2_df
|
|
288
|
|
289
|
|
290
|
|
291 def normalisef(f,max):
|
|
292 return f/max
|
|
293
|
|
294 def getComposite_sum2(nameList,sum2_dfs):
|
|
295 # lets get a composite sum2_df from all of the sum2_dfs
|
|
296 phyList = []
|
|
297
|
|
298 for i in range(0, len(sum2_dfs)):
|
|
299 total = sum2_dfs[i]['FPKM'].sum()
|
|
300 sum2_dfs[i]['w'] = sum2_dfs[i].apply(lambda row: normalisef(row['FPKM'], total), axis=1)
|
|
301 pSeries = sum2_dfs[i]['Phylotype']
|
|
302 for p in pSeries:
|
|
303 phyList.append(p) # get all the phylotypes in this one
|
|
304 phyList = list(set(phyList))
|
|
305 phyList.sort()
|
|
306 composite_sum2_df = pd.DataFrame(phyList, columns=['Phylotype'])
|
|
307 for i in range(0, len(sum2_dfs)):
|
|
308 wList = []
|
|
309 pindf = list(sum2_dfs[i]['Phylotype'])
|
|
310 # print(pindf)
|
|
311 for p in phyList:
|
|
312 if p in pindf:
|
|
313 df = sum2_dfs[i]
|
|
314 w = df.loc[df['Phylotype'] == p, 'w'].iloc[0]
|
|
315 else:
|
|
316 w = 0
|
|
317 wList.append(w)
|
|
318 composite_sum2_df[nameList[i]] = wList
|
|
319 #print(composite_sum2_df)
|
|
320 #composite_sum2_df.to_csv('composite.csv')
|
|
321 return composite_sum2_df
|
|
322
|
|
323
|
|
324 def doMultiBarChart(tdict, composite_df): #array of multiple sum2_dfs
|
|
325 labelList = composite_df.columns.tolist()
|
|
326 sampnum = len(labelList)-1
|
|
327 # need to arrange bars
|
|
328 # number of phylotype = len(composite_df)
|
|
329 #number of bars = (len(labelist)-1) +1 for space
|
|
330 # ytick needs to ne
|
|
331
|
|
332 cmap = plt.cm.get_cmap('tab10')
|
|
333 palette = [cmap(i) for i in range(cmap.N)]
|
|
334 title = "Legend: Variant Antigen Profile of a $\itTrypanosoma$ $\itvivax$ transcriptomes. " \
|
|
335 "Phylotype abundance is expressed as phylotype frequencies adjusted " \
|
|
336 "for combined transcript abundance. " \
|
|
337 "Data was produced with VAPPER-Variant Antigen Profiler (Silva Pereira et al., 2019)."
|
|
338 width = 0.6
|
|
339 ind = np.arange(width*sampnum/2, len(composite_df)*width*(sampnum+1), width*(sampnum+1))
|
|
340 #print(ind)
|
|
341 ysize = len(composite_df)*0.4
|
|
342
|
|
343 fig, ax = plt.subplots(figsize=(10,ysize))
|
|
344
|
|
345
|
|
346 for s in range(1, len(labelList)):
|
|
347 ax.barh(ind, composite_df[labelList[s]], width, color=palette[s], label=labelList[s])
|
|
348 ind = ind + width
|
|
349
|
|
350 ax.set(yticks=np.arange(width*(sampnum+2)/2, len(composite_df)*width*(sampnum+1), width*(sampnum+1)), yticklabels=composite_df['Phylotype']) # , ylim=[(len(labelList)-1) * width - 1, len(composite_df)])
|
|
351 ax.legend()
|
|
352
|
|
353
|
|
354 ax.set_ylabel('Phylotype')
|
|
355 ax.invert_yaxis() # labels read top-to-bottom
|
|
356 ax.set_xlabel('Weighted Phylotype Frequency')
|
|
357
|
|
358 # plt.text(-0.3, -0.15, title, va="top", wrap="True")
|
|
359 #plt.tight_layout()
|
|
360
|
|
361 plt.subplots_adjust(bottom=0.1, top=0.92, left=0.15, right=0.9)
|
|
362 ax.set_title(title, x=0, wrap='True',ha='left',)
|
|
363
|
|
364 plt.savefig(tdict['html_resource'] + tdict['name']+"_phylotypes.png")
|
|
365 if tdict['pdf'] == 'PDF_Yes':
|
|
366 plt.savefig(tdict['html_resource'] + tdict['name']+"phylotypes.pdf")
|
27
|
367 # plt.show()
|
19
|
368 pass
|
|
369
|
|
370
|
|
371
|
|
372 def doBarChart(tdict, sum2_df):
|
|
373 cmap = plt.cm.get_cmap('tab20')
|
|
374 palette = [cmap(i) for i in range(cmap.N)]
|
|
375 title = "Legend: Variant Antigen Profile of a $\itTrypanosoma$ $\itvivax$ transcriptome. " \
|
|
376 "Phylotype abundance is expressed as phylotype frequencies adjusted " \
|
|
377 "for combined transcript abundance. " \
|
|
378 "Data was produced with VAPPER-Variant Antigen Profiler (Silva Pereira et al., 2019)."
|
|
379 # get a list of phylotype, create equivalent of saccver, get a list of
|
|
380 maxFPKM = sum2_df['FPKM'].max()
|
|
381 total = sum2_df['FPKM'].sum()
|
|
382
|
|
383 sum2_df['Normalised'] = sum2_df.apply(lambda row: normalisef(row['FPKM'], maxFPKM),axis=1)
|
|
384 sum2_df['Weighted'] = sum2_df.apply(lambda row: normalisef(row['FPKM'], total),axis=1)
|
|
385 pList = sum2_df['Phylotype']
|
|
386 phList = []
|
|
387 for p in pList:
|
|
388 phList.append(str(p))
|
|
389
|
|
390 fList = sum2_df['Weighted']
|
|
391 ysize = len(phList)*0.3
|
|
392 fig, ax = plt.subplots(figsize=(10,ysize))
|
|
393
|
|
394 ax.barh(phList, fList, color=palette)
|
|
395 ax.set_ylabel('Phylotype')
|
|
396 ax.invert_yaxis() # labels read top-to-bottom
|
|
397 ax.set_xlabel('Weighted Phylotype Frequency')
|
|
398
|
|
399 # plt.text(-0.3, -0.15, title, va="top", wrap="True")
|
|
400 #plt.tight_layout()
|
|
401 plt.subplots_adjust(bottom=0.1, top=0.9, left=0.15, right=0.9)
|
|
402 ax.set_title(title, x=0, wrap='True',ha='left',)
|
|
403
|
25
|
404 plt.savefig(tdict['html_resource'] + '/' + tdict['name']+"_phylotypes.png")
|
19
|
405 if tdict['pdf'] == 'PDF_Yes':
|
25
|
406 plt.savefig(tdict['html_resource'] + '/' + tdict['name']+"phylotypes.pdf")
|
19
|
407 # plt.show()
|
|
408 pass
|
|
409
|
|
410 # argdict = {'name':2, 'pdfexport': 3, 'refFastq': 4, 'forward': 5, 'reverse': 6, 'html_file': 7, 'html_resource': 8}
|
|
411
|
|
412 def transcriptomicProcess(args,argdict):
|
21
|
413 dir_path = os.path.dirname(os.path.realpath(__file__))
|
19
|
414 tdict = {}
|
|
415 tdict['name'] = args[argdict['name']]
|
|
416 tdict['refFastq'] = args[argdict['refFastq']]
|
|
417 tdict['forward'] = args[argdict['forward']]
|
|
418 tdict['reverse'] = args[argdict['reverse']]
|
21
|
419 dir_path = os.path.dirname(os.path.realpath(__file__))
|
|
420 tdict['vivax_trans_database'] = dir_path+'/data/vivax/Database/Phylotype_typeseqs.fas'
|
19
|
421 tdict['pdf'] = args[argdict['pdfexport']]
|
|
422 tdict['html_file'] = args[argdict['html_file']]
|
|
423 tdict['html_resource'] = args[argdict['html_resource']]
|
|
424
|
|
425 uploadUserReferenceFastq(tdict['refFastq'])
|
|
426 transcriptMapping(tdict['name'], tdict['refFastq'], tdict['forward'], tdict['reverse']) #uses bowtie
|
|
427 processSamFiles(tdict['name']) #uses samtools
|
|
428 transcriptAbundance(tdict['name']) #uses cufflinks -> ?.cuff/*.*
|
|
429 transcriptsForBlast(tdict['name'], tdict['refFastq']) #creates name+4blast.fa
|
21
|
430 blastContigs(tdict['name'], tdict['html_resource'], tdict['vivax_trans_database'])
|
19
|
431 sum_df, sum2_df = combineFPMK(tdict)
|
|
432 doBarChart(tdict, sum2_df)
|
|
433 createHTML(tdict, sum_df)
|
|
434
|
|
435
|
|
436 if __name__ == "__main__":
|
|
437 exit()
|
|
438
|
|
439
|