|
18
|
1 #!/usr/bin/env python
|
|
|
2
|
|
|
3 # Copyright INRA (Institut National de la Recherche Agronomique)
|
|
|
4 # http://www.inra.fr
|
|
|
5 # http://urgi.versailles.inra.fr
|
|
|
6 #
|
|
|
7 # This software is governed by the CeCILL license under French law and
|
|
|
8 # abiding by the rules of distribution of free software. You can use,
|
|
|
9 # modify and/ or redistribute the software under the terms of the CeCILL
|
|
|
10 # license as circulated by CEA, CNRS and INRIA at the following URL
|
|
|
11 # "http://www.cecill.info".
|
|
|
12 #
|
|
|
13 # As a counterpart to the access to the source code and rights to copy,
|
|
|
14 # modify and redistribute granted by the license, users are provided only
|
|
|
15 # with a limited warranty and the software's author, the holder of the
|
|
|
16 # economic rights, and the successive licensors have only limited
|
|
|
17 # liability.
|
|
|
18 #
|
|
|
19 # In this respect, the user's attention is drawn to the risks associated
|
|
|
20 # with loading, using, modifying and/or developing or reproducing the
|
|
|
21 # software by the user in light of its specific status of free software,
|
|
|
22 # that may mean that it is complicated to manipulate, and that also
|
|
|
23 # therefore means that it is reserved for developers and experienced
|
|
|
24 # professionals having in-depth computer knowledge. Users are therefore
|
|
|
25 # encouraged to load and test the software's suitability as regards their
|
|
|
26 # requirements in conditions enabling the security of their systems and/or
|
|
|
27 # data to be ensured and, more generally, to use and operate it in the
|
|
|
28 # same conditions as regards security.
|
|
|
29 #
|
|
|
30 # The fact that you are presently reading this means that you have had
|
|
|
31 # knowledge of the CeCILL license and that you accept its terms.
|
|
|
32
|
|
|
33
|
|
|
34 import os
|
|
|
35 import sys
|
|
|
36 import getopt
|
|
|
37 from commons.core.coord.Align import Align
|
|
|
38 from commons.core.coord.Path import Path
|
|
|
39 from commons.core.coord.Match import Match
|
|
|
40
|
|
|
41
|
|
|
42
|
|
|
43 class ChangeSequenceHeaders( object ):
|
|
|
44
|
|
|
45 def __init__( self, name="ChangeSequenceHeaders", inFile="", format="", step=0, prefix="seq", outFile="",linkFile="", whichCluster = "", replace_query=True, replace_subject=True, verbosity=0):
|
|
|
46 self._name = name
|
|
|
47 self._inFile = inFile
|
|
|
48 self._format = format
|
|
|
49 self._step = step
|
|
|
50 self._prefix = prefix
|
|
|
51 self._linkFile = linkFile
|
|
|
52 self._whichCluster = whichCluster
|
|
|
53 self._outFile = outFile
|
|
|
54 self.replace_query = replace_query
|
|
|
55 self.replace_subject = replace_subject
|
|
|
56 self._verbose = verbosity
|
|
|
57
|
|
|
58
|
|
|
59 def help( self ):
|
|
|
60 print
|
|
|
61 print "usage: %s.py [ options ]" % ( self._name )
|
|
|
62 print "options:"
|
|
|
63 print " -h: this help"
|
|
|
64 print " -i: name of the input file"
|
|
|
65 print " -f: format of the input file (fasta/newick/align/path/tab)"
|
|
|
66 print " -s: step (1: shorten headers / 2: retrieve initial headers)"
|
|
|
67 print " -p: prefix of new headers (with '-s 1', default='seq')"
|
|
|
68 print " -l: name of the 'link' file (with '-s 2', format=map)"
|
|
|
69 print " -w: header formatting type (A: after LTRharvest, B: for ClusterConsensus, not specified: no change)"
|
|
|
70 print " -o: name of the output file (default=inFile+'.newH'/'.initH')"
|
|
|
71 print
|
|
|
72
|
|
|
73
|
|
|
74 def setAttributesFromCmdLine( self ):
|
|
|
75 try:
|
|
|
76 opts, args = getopt.getopt(sys.argv[1:],"hi:f:s:p:l:w:o:v:")
|
|
|
77 except getopt.GetoptError, err:
|
|
|
78 sys.stderr.write( "%s\n" % ( str(err) ) )
|
|
|
79 self.help(); sys.exit(1)
|
|
|
80 for o,a in opts:
|
|
|
81 if o == "-h":
|
|
|
82 self.help(); sys.exit(0)
|
|
|
83 elif o == "-i":
|
|
|
84 self.setInputFile( a )
|
|
|
85 elif o == "-f":
|
|
|
86 self.setFormat( a )
|
|
|
87 elif o == "-s":
|
|
|
88 self.setStep( a )
|
|
|
89 elif o == "-p":
|
|
|
90 self.setPrefix( a )
|
|
|
91 elif o == "-l":
|
|
|
92 self.setLinkFile( a )
|
|
|
93 elif o == "-w":
|
|
|
94 self.setWhichcluster( a )
|
|
|
95 elif o == "-o":
|
|
|
96 self.setOutputFile( a )
|
|
|
97 elif o == "-v":
|
|
|
98 self.setVerbosityLevel( a )
|
|
|
99
|
|
|
100
|
|
|
101 def setInputFile( self, inFile ):
|
|
|
102 self._inFile = inFile
|
|
|
103
|
|
|
104 def setFormat( self, format ):
|
|
|
105 self._format = format
|
|
|
106
|
|
|
107 def setPrefix( self, prefix ):
|
|
|
108 self._prefix = prefix
|
|
|
109
|
|
|
110 def setStep( self, step ):
|
|
|
111 self._step = int(step)
|
|
|
112
|
|
|
113 def setLinkFile( self, linkFile ):
|
|
|
114 self._linkFile = linkFile
|
|
|
115
|
|
|
116 def setWhichcluster( self, whichCluster ):
|
|
|
117 self._whichCluster = whichCluster
|
|
|
118
|
|
|
119 def setOutputFile( self, outFile ):
|
|
|
120 self._outFile = outFile
|
|
|
121
|
|
|
122 def setVerbosityLevel( self, verbose ):
|
|
|
123 self._verbose = int(verbose)
|
|
|
124
|
|
|
125
|
|
|
126 def checkAttributes( self ):
|
|
|
127 if self._inFile == "":
|
|
|
128 sys.stderr.write( "ERROR: missing input file name (-i)\n" )
|
|
|
129 self.help(); sys.exit(1)
|
|
|
130 if not os.path.exists( self._inFile ):
|
|
|
131 sys.stderr.write( "ERROR: input file doesn't exist (-i)\n" )
|
|
|
132 self.help(); sys.exit(1)
|
|
|
133 if self._format not in ["fasta","newick","align","path","tab","axt","lastz", "psl","chain"]:
|
|
|
134 sys.stderr.write( "ERROR: unrecognized format '%s' (-f)\n" )
|
|
|
135 self.help(); sys.exit(1)
|
|
|
136 if self._step not in [1,2]:
|
|
|
137 sys.stderr.write( "ERROR: missing step (-s)\n" )
|
|
|
138 self.help(); sys.exit(1)
|
|
|
139 if self._step == 1 and self._prefix == "":
|
|
|
140 sys.stderr.write( "ERROR: missing prefix (-p)\n" )
|
|
|
141 self.help(); sys.exit(1)
|
|
|
142 if self._step == 2:
|
|
|
143 if self._linkFile == "":
|
|
|
144 sys.stderr.write( "ERROR: missing link file name (-l)\n" )
|
|
|
145 self.help(); sys.exit(1)
|
|
|
146 if not os.path.exists( self._linkFile ):
|
|
|
147 sys.stderr.write( "ERROR: link file doesn't exist (-l)\n" )
|
|
|
148 self.help(); sys.exit(1)
|
|
|
149 if self._whichCluster not in ["A", "B", ""]:
|
|
|
150 sys.stderr.write( "ERROR: formatting type not available (-w option): %s\n" % self._whichCluster)
|
|
|
151 self.help(); sys.exit(1)
|
|
|
152 if self._outFile == "":
|
|
|
153 if self._step == 1:
|
|
|
154 self._outFile = "%s.newH" % ( self._inFile )
|
|
|
155 elif self._step == 2:
|
|
|
156 self._outFile = "%s.initH" % ( self._inFile )
|
|
|
157
|
|
|
158
|
|
|
159 def shortenSequenceHeadersForFastaFile( self ):
|
|
|
160 if self._verbose > 0:
|
|
|
161 print "shorten sequence headers for fasta file..."
|
|
|
162 sys.stdout.flush()
|
|
|
163 if self._verbose > 1:
|
|
|
164 print "save sequences in '%s'" %( self._outFile )
|
|
|
165 inFileHandler = open( self._inFile, "r" )
|
|
|
166 linkFileHandler = open( self._linkFile, "w" )
|
|
|
167 outFileHandler = open( self._outFile, "w" )
|
|
|
168 countSeq = 0
|
|
|
169 lengthSeq = 0
|
|
|
170 while True:
|
|
|
171 line = inFileHandler.readline()
|
|
|
172 if line == "":
|
|
|
173 break
|
|
|
174 if line[0] == ">":
|
|
|
175 countSeq += 1
|
|
|
176 newHeader = "%s%i" % ( self._prefix, countSeq )
|
|
|
177 if self._verbose > 1:
|
|
|
178 print "initial '%s' -> new '%s'" % ( line[1:-1], newHeader )
|
|
|
179 outFileHandler.write( ">%s\n" % ( newHeader ) )
|
|
|
180 if lengthSeq != 0:
|
|
|
181 linkFileHandler.write( "\t%i\t%i\n" % ( 1, lengthSeq ) )
|
|
|
182 lengthSeq = 0
|
|
|
183 linkFileHandler.write( "%s\t%s" % ( newHeader, line[1:-1] ) )
|
|
|
184 else:
|
|
|
185 lengthSeq += len( line.replace("\n","") )
|
|
|
186 outFileHandler.write( line )
|
|
|
187 linkFileHandler.write( "\t%i\t%i\n" % ( 1, lengthSeq ) )
|
|
|
188 inFileHandler.close()
|
|
|
189 linkFileHandler.close()
|
|
|
190 outFileHandler.close()
|
|
|
191 if self._verbose > 0:
|
|
|
192 print "nb of sequences: %i" % ( countSeq )
|
|
|
193
|
|
|
194
|
|
|
195 def getLinksNewToInitialHeaders( self ):
|
|
|
196 if self._verbose > 0:
|
|
|
197 print "retrieve the links new->initial headers"
|
|
|
198 sys.stdout.flush()
|
|
|
199 dNew2Init = {}
|
|
|
200 linkFileHandler = open( self._linkFile,"r" )
|
|
|
201 while True:
|
|
|
202 line = linkFileHandler.readline()
|
|
|
203 if line == "":
|
|
|
204 break
|
|
|
205 tokens = line.split("\t")
|
|
|
206 if len(tokens) == 4:
|
|
|
207 dNew2Init[ tokens[0] ] = tokens[1]
|
|
|
208 elif len(tokens) == 2:
|
|
|
209 dNew2Init[ tokens[0] ] = tokens[1].split("\n")[0]
|
|
|
210 else:
|
|
|
211 sys.stderr.write( "ERROR: link file is badly formatted\n" )
|
|
|
212 sys.exit(1)
|
|
|
213 linkFileHandler.close()
|
|
|
214 if self._verbose > 0: print "nb of links: %i" % ( len(dNew2Init.keys()) ); sys.stdout.flush()
|
|
|
215 return dNew2Init
|
|
|
216
|
|
|
217
|
|
|
218 def retrieveInitialSequenceHeadersForFastaFile( self, dNew2Init ):
|
|
|
219 if self._verbose > 0:
|
|
|
220 print "retrieve initial headers for fasta file"
|
|
|
221 sys.stdout.flush()
|
|
|
222 inFileHandler = open( self._inFile, "r" )
|
|
|
223 outFileHandler = open( self._outFile, "w" )
|
|
|
224 countSeq = 0
|
|
|
225 while True:
|
|
|
226 line = inFileHandler.readline()
|
|
|
227 if line == "":
|
|
|
228 break
|
|
|
229 if line[0] == ">":
|
|
|
230 if self._whichCluster == "":
|
|
|
231 initHeader = line[1:-1]
|
|
|
232 newHeader = dNew2Init[initHeader]
|
|
|
233 else:
|
|
|
234 tokens = line[1:-1].split("_")
|
|
|
235 initHeader = dNew2Init[tokens[1]]
|
|
|
236
|
|
|
237 pattern = ""
|
|
|
238 if "BlastclustCluster" in tokens[0]:
|
|
|
239 pattern = "Blc"
|
|
|
240 if "MCLCluster" in tokens[0]:
|
|
|
241 pattern = "MCL"
|
|
|
242
|
|
|
243 if self._whichCluster == "A":
|
|
|
244 newHeader = "%s_%s" % (tokens[0], initHeader)
|
|
|
245 elif self._whichCluster == "B":
|
|
|
246 classif = initHeader.split("_")[0]
|
|
|
247 consensusName = "_".join(initHeader.split("_")[1:])
|
|
|
248 clusterId = tokens[0].split("Cluster")[1].split("Mb")[0]
|
|
|
249 newHeader = "%s_%s%s_%s" % (classif, pattern, clusterId, consensusName)
|
|
|
250
|
|
|
251 outFileHandler.write( ">%s\n" % newHeader )
|
|
|
252 else:
|
|
|
253 outFileHandler.write( line )
|
|
|
254 inFileHandler.close()
|
|
|
255 outFileHandler.close()
|
|
|
256 if self._verbose > 0:
|
|
|
257 print "nb of sequences: %i" % ( countSeq )
|
|
|
258
|
|
|
259
|
|
|
260 def retrieveInitialSequenceHeadersForNewickFile( self, dNew2Init ):
|
|
|
261 inF = open( self._inFile, "r" )
|
|
|
262 lines = inF.readlines()
|
|
|
263 inF.close()
|
|
|
264 line = "".join(lines) #.replace(";","").replace("\n","")
|
|
|
265 outF = open( self._outFile, "w" )
|
|
|
266 for newH in dNew2Init.keys():
|
|
|
267 line = line.replace( newH+":", dNew2Init[newH].replace(" ","_").replace("::","-").replace(":","-").replace(",","-")+":" )
|
|
|
268 outF.write( line )
|
|
|
269 outF.close()
|
|
|
270
|
|
|
271
|
|
|
272 def retrieveInitialSequenceHeadersForAlignFile( self, dNew2Init ):
|
|
|
273 inFileHandler = open( self._inFile, "r" )
|
|
|
274 outFileHandler = open( self._outFile, "w" )
|
|
|
275 a = Align()
|
|
|
276 while True:
|
|
|
277 line = inFileHandler.readline()
|
|
|
278 if line == "":
|
|
|
279 break
|
|
|
280 a.setFromTuple( line.split("\t") )
|
|
|
281 nameToBeReplaced = a.range_query.seqname
|
|
|
282 if dNew2Init.has_key( nameToBeReplaced ):
|
|
|
283 a.range_query.seqname = dNew2Init[ nameToBeReplaced ]
|
|
|
284 nameToBeReplaced = a.range_subject.seqname
|
|
|
285 if dNew2Init.has_key( nameToBeReplaced ):
|
|
|
286 a.range_subject.seqname = dNew2Init[ nameToBeReplaced ]
|
|
|
287 a.write( outFileHandler )
|
|
|
288 inFileHandler.close()
|
|
|
289 outFileHandler.close()
|
|
|
290
|
|
|
291
|
|
|
292 def retrieveInitialSequenceHeadersForPathFile( self, dNew2Init ):
|
|
|
293 inFileHandler = open( self._inFile, "r" )
|
|
|
294 outFileHandler = open( self._outFile, "w" )
|
|
|
295 p = Path()
|
|
|
296 while True:
|
|
|
297 line = inFileHandler.readline()
|
|
|
298 if line == "":
|
|
|
299 break
|
|
|
300 p.setFromTuple( line.split("\t") )
|
|
|
301 nameToBeReplaced = p.range_query.seqname
|
|
|
302 if dNew2Init.has_key( nameToBeReplaced ):
|
|
|
303 p.range_query.seqname = dNew2Init[ nameToBeReplaced ]
|
|
|
304 nameToBeReplaced = p.range_subject.seqname
|
|
|
305 if dNew2Init.has_key( nameToBeReplaced ):
|
|
|
306 p.range_subject.seqname = dNew2Init[ nameToBeReplaced ]
|
|
|
307 p.write( outFileHandler )
|
|
|
308 inFileHandler.close()
|
|
|
309 outFileHandler.close()
|
|
|
310
|
|
|
311
|
|
|
312 def retrieveInitialSequenceHeadersForMatchFile( self, dNew2Init ):
|
|
|
313 inFileHandler = open( self._inFile, "r" )
|
|
|
314 outFileHandler = open( self._outFile, "w" )
|
|
|
315 m = Match()
|
|
|
316 while True:
|
|
|
317 line = inFileHandler.readline()
|
|
|
318 if line == "":
|
|
|
319 break
|
|
|
320 if line[0:10] == "query.name":
|
|
|
321 continue
|
|
|
322 m.setFromTuple( line.split("\t") )
|
|
|
323 nameToBeReplaced = m.range_query.seqname
|
|
|
324 if dNew2Init.has_key( nameToBeReplaced ):
|
|
|
325 m.range_query.seqname = dNew2Init[ nameToBeReplaced ]
|
|
|
326 nameToBeReplaced = m.range_subject.seqname
|
|
|
327 if dNew2Init.has_key( nameToBeReplaced ):
|
|
|
328 m.range_subject.seqname = dNew2Init[ nameToBeReplaced ]
|
|
|
329 m.write( outFileHandler )
|
|
|
330 inFileHandler.close()
|
|
|
331 outFileHandler.close()
|
|
|
332
|
|
|
333 def retrieveInitialSequenceHeadersForAxtFile( self, dNew2Init):
|
|
|
334 inFileHandler = open( self._inFile, "r" )
|
|
|
335 outFileHandler = open( self._outFile, "w" )
|
|
|
336 while True:
|
|
|
337 try:
|
|
|
338 line = inFileHandler.next()
|
|
|
339 except StopIteration:
|
|
|
340 break
|
|
|
341
|
|
|
342 if line == "" or not "seq" in line:
|
|
|
343 outFileHandler.write(line)
|
|
|
344 else :
|
|
|
345 elems = line.split(" ")
|
|
|
346 try:
|
|
|
347 subject_seqname = elems[1]
|
|
|
348 if self.replace_subject :
|
|
|
349 nameToBeReplaced = elems[1]
|
|
|
350 if dNew2Init.has_key( nameToBeReplaced ):
|
|
|
351 subject_seqname = dNew2Init[nameToBeReplaced]
|
|
|
352 subject_seqname = subject_seqname.strip('\n').strip('\r')
|
|
|
353
|
|
|
354 query_seqname = elems[4]
|
|
|
355 if self.replace_query:
|
|
|
356 nameToBeReplaced = elems[4]
|
|
|
357 if dNew2Init.has_key( nameToBeReplaced ):
|
|
|
358 query_seqname = dNew2Init[nameToBeReplaced]
|
|
|
359 query_seqname = query_seqname.strip('\n').strip('\r')
|
|
|
360
|
|
|
361 modedelems = [ elems[0], subject_seqname, elems[2], elems[3], query_seqname, elems[5], elems[6], elems[7], elems[8]]
|
|
|
362 newLine = " ".join(modedelems)
|
|
|
363 outFileHandler.write("%s\n" % newLine)
|
|
|
364 if self._verbose >0 :
|
|
|
365 print("query", query_seqname, "subject", subject_seqname)
|
|
|
366 print("Output axt_line : line %s " % newLine)
|
|
|
367 except: pass
|
|
|
368 inFileHandler.close()
|
|
|
369 outFileHandler.close()
|
|
|
370
|
|
|
371 def retrieveInitialSequenceHeadersForPslFile( self, dNew2Init):
|
|
|
372
|
|
|
373 inFileHandler = open( self._inFile, "r" )
|
|
|
374 outFileHandler = open( self._outFile, "w" )
|
|
|
375 while True:
|
|
|
376 try:
|
|
|
377 line = inFileHandler.next()
|
|
|
378 except StopIteration:
|
|
|
379 break
|
|
|
380
|
|
|
381 if line == "" or not "seq" in line:
|
|
|
382 outFileHandler.write(line)
|
|
|
383 else :
|
|
|
384 elems = line.split()
|
|
|
385 try:
|
|
|
386 subject_seqname = elems[13]
|
|
|
387 if self.replace_subject :
|
|
|
388 nameToBeReplaced = elems[13]
|
|
|
389 if dNew2Init.has_key( nameToBeReplaced ):
|
|
|
390 subject_seqname = dNew2Init[nameToBeReplaced]
|
|
|
391 subject_seqname = subject_seqname.strip('\n').strip('\r')
|
|
|
392
|
|
|
393 query_seqname = elems[9]
|
|
|
394 if self.replace_query:
|
|
|
395 nameToBeReplaced = elems[9]
|
|
|
396 if dNew2Init.has_key( nameToBeReplaced ):
|
|
|
397 query_seqname = dNew2Init[nameToBeReplaced]
|
|
|
398 query_seqname = query_seqname.strip('\n').strip('\r')
|
|
|
399
|
|
|
400 modedelems =elems[0:9]+[query_seqname]+elems[10:13]+[subject_seqname]+elems[14:21]
|
|
|
401 #modedelems = [ elems[0], elems[1], elems[2], elems[3], elems[4], elems[5], elems[6], elems[7], elems[8], query_seqname, ]
|
|
|
402 #modedelems = [ elems[0], subject_seqname, elems[2], elems[3], query_seqname, elems[5], elems[6], elems[7], elems[8]]
|
|
|
403 newLine = "\t".join(modedelems)
|
|
|
404 outFileHandler.write("%s\n" % newLine)
|
|
|
405 if self._verbose >0 :
|
|
|
406 print("query", query_seqname, "subject", subject_seqname)
|
|
|
407 print("Output psl_line : line %s " % newLine)
|
|
|
408 except: pass
|
|
|
409 sys.stdout.flush()
|
|
|
410 inFileHandler.close()
|
|
|
411 outFileHandler.close()
|
|
|
412
|
|
|
413
|
|
|
414 def retrieveInitialSequenceHeadersForLastZFile( self, dNew2Init):
|
|
|
415 inFileHandler = open( self._inFile, "r" )
|
|
|
416 outFileHandler = open( self._outFile, "w" )
|
|
|
417 while True:
|
|
|
418 try:
|
|
|
419 line = inFileHandler.next()
|
|
|
420 except StopIteration:
|
|
|
421 break
|
|
|
422 #score, name1, strand1, size1, zstart1, end1, name2, strand2, size2, zstart2, end2, identity, coverage
|
|
|
423
|
|
|
424 if line == "" or not "seq" in line:
|
|
|
425 outFileHandler.write(line)
|
|
|
426 else :
|
|
|
427 elems = line.split("\t")
|
|
|
428 try:
|
|
|
429 subject_seqname = elems[1]
|
|
|
430 if self.replace_subject :
|
|
|
431 nameToBeReplaced = elems[1]
|
|
|
432 if dNew2Init.has_key( nameToBeReplaced ):
|
|
|
433 subject_seqname = dNew2Init[nameToBeReplaced]
|
|
|
434 subject_seqname = subject_seqname.strip('\n').strip('\r')
|
|
|
435
|
|
|
436 query_seqname = elems[6]
|
|
|
437 if self.replace_query:
|
|
|
438 nameToBeReplaced = elems[6]
|
|
|
439 if dNew2Init.has_key( nameToBeReplaced ):
|
|
|
440 query_seqname = dNew2Init[nameToBeReplaced]
|
|
|
441 query_seqname = query_seqname.strip('\n').strip('\r')
|
|
|
442
|
|
|
443 modedelems = [ elems[0], subject_seqname, elems[2], elems[3], elems[4], elems[5], query_seqname, elems[7], elems[8],elems[9],elems[10], elems[11], elems[12],elems[13],elems[14].strip('\n').strip('\r')]
|
|
|
444 newLine = "\t".join(modedelems)
|
|
|
445 outFileHandler.write("%s\n" % newLine)
|
|
|
446 if self._verbose >0 :
|
|
|
447 print("query", query_seqname, "subject", subject_seqname)
|
|
|
448 print("Output lastz_line : line %s " % newLine)
|
|
|
449 except: pass
|
|
|
450 inFileHandler.close()
|
|
|
451 outFileHandler.close()
|
|
|
452
|
|
|
453 def retrieveInitialSequenceHeadersForChainFile( self, dNew2Init):
|
|
|
454 #format: chain score tName tSize tStrand tStart tEnd qName qSize qStrand qStart qEnd id
|
|
|
455 inFileHandler = open( self._inFile, "r" )
|
|
|
456 outFileHandler = open( self._outFile, "w" )
|
|
|
457 while True:
|
|
|
458 try:
|
|
|
459 line = inFileHandler.next()
|
|
|
460 except StopIteration:
|
|
|
461 break
|
|
|
462 if line == "" or not "seq" in line:
|
|
|
463 outFileHandler.write(line)
|
|
|
464 else :
|
|
|
465 elems = line.split(" ")
|
|
|
466 try:
|
|
|
467 subject_seqname = elems[2]
|
|
|
468 if self.replace_subject :
|
|
|
469 nameToBeReplaced = elems[2]
|
|
|
470 if dNew2Init.has_key( nameToBeReplaced ):
|
|
|
471 subject_seqname = dNew2Init[nameToBeReplaced]
|
|
|
472 subject_seqname = subject_seqname.strip('\n').strip('\r')
|
|
|
473
|
|
|
474 query_seqname = elems[7]
|
|
|
475 if self.replace_query:
|
|
|
476 nameToBeReplaced = elems[7]
|
|
|
477 if dNew2Init.has_key( nameToBeReplaced ):
|
|
|
478 query_seqname = dNew2Init[nameToBeReplaced]
|
|
|
479 query_seqname = query_seqname.strip('\n').strip('\r')
|
|
|
480
|
|
|
481 modedelems = elems[:]
|
|
|
482 modedelems[2] = subject_seqname
|
|
|
483 modedelems[7] = query_seqname
|
|
|
484 newLine = " ".join(modedelems)
|
|
|
485 outFileHandler.write("%s\n" % newLine)
|
|
|
486 except: pass
|
|
|
487
|
|
|
488 inFileHandler.close()
|
|
|
489 outFileHandler.close()
|
|
|
490
|
|
|
491
|
|
|
492 def run( self ):
|
|
|
493 self.checkAttributes()
|
|
|
494 if self._step == 1:
|
|
|
495 if self._linkFile == "":
|
|
|
496 self._linkFile = "%s.newHlink" % ( self._inFile )
|
|
|
497 if self._format == "fasta":
|
|
|
498 self.shortenSequenceHeadersForFastaFile()
|
|
|
499 if self._step == 2:
|
|
|
500 dNew2Init = self.getLinksNewToInitialHeaders()
|
|
|
501 if self._format == "fasta":
|
|
|
502 self.retrieveInitialSequenceHeadersForFastaFile( dNew2Init )
|
|
|
503 elif self._format == "newick":
|
|
|
504 self.retrieveInitialSequenceHeadersForNewickFile( dNew2Init )
|
|
|
505 elif self._format == "align":
|
|
|
506 self.retrieveInitialSequenceHeadersForAlignFile( dNew2Init )
|
|
|
507 elif self._format == "path":
|
|
|
508 self.retrieveInitialSequenceHeadersForPathFile( dNew2Init )
|
|
|
509 elif self._format == "axt":
|
|
|
510 self.retrieveInitialSequenceHeadersForAxtFile( dNew2Init)
|
|
|
511 elif self._format == "psl":
|
|
|
512 self.retrieveInitialSequenceHeadersForPslFile( dNew2Init)
|
|
|
513 elif self._format == "lastz":
|
|
|
514 self.retrieveInitialSequenceHeadersForLastZFile(dNew2Init)
|
|
|
515 elif self._format == "chain":
|
|
|
516 self.retrieveInitialSequenceHeadersForChainFile(dNew2Init)
|
|
|
517 elif self._format in [ "tab", "match" ]:
|
|
|
518 self.retrieveInitialSequenceHeadersForMatchFile( dNew2Init )
|
|
|
519
|
|
|
520
|
|
|
521 if __name__ == "__main__":
|
|
|
522 i = ChangeSequenceHeaders()
|
|
|
523 i.setAttributesFromCmdLine()
|
|
|
524 i.run() |
