Mercurial > repos > devteam > data_manager_fetch_genome_dbkeys_all_fasta
comparison data_manager/data_manager_fetch_genome_all_fasta_dbkeys.py @ 0:c669787306ae draft
Uploaded
author | devteam |
---|---|
date | Tue, 03 Feb 2015 10:08:46 -0500 |
parents | |
children | bca4c608408c |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:c669787306ae |
---|---|
1 #!/usr/bin/env python | |
2 #Dan Blankenberg | |
3 | |
4 import sys | |
5 import os | |
6 import tempfile | |
7 import shutil | |
8 import optparse | |
9 import urllib2 | |
10 #import uuid | |
11 from ftplib import FTP | |
12 import tarfile | |
13 import zipfile | |
14 import gzip | |
15 import bz2 | |
16 | |
17 from json import loads, dumps | |
18 | |
19 | |
20 CHUNK_SIZE = 2**20 #1mb | |
21 | |
22 def cleanup_before_exit( tmp_dir ): | |
23 if tmp_dir and os.path.exists( tmp_dir ): | |
24 shutil.rmtree( tmp_dir ) | |
25 | |
26 def stop_err(msg): | |
27 sys.stderr.write(msg) | |
28 sys.exit(1) | |
29 | |
30 def get_dbkey_dbname_id_name( params, dbkey_description=None ): | |
31 dbkey = params['param_dict']['dbkey_source']['dbkey'] | |
32 #TODO: ensure sequence_id is unique and does not already appear in location file | |
33 sequence_id = params['param_dict']['sequence_id'] | |
34 if not sequence_id: | |
35 sequence_id = dbkey #uuid.uuid4() generate and use an uuid instead? | |
36 | |
37 if params['param_dict']['dbkey_source']['dbkey_source_selector'] == 'new': | |
38 dbkey_name = params['param_dict']['dbkey_source']['dbkey_name'] | |
39 if not dbkey_name: | |
40 dbkey_name = dbkey | |
41 else: | |
42 dbkey_name = None | |
43 | |
44 sequence_name = params['param_dict']['sequence_name'] | |
45 if not sequence_name: | |
46 sequence_name = dbkey_description | |
47 if not sequence_name: | |
48 sequence_name = dbkey | |
49 return dbkey, dbkey_name, sequence_id, sequence_name | |
50 | |
51 def _get_files_in_ftp_path( ftp, path ): | |
52 path_contents = [] | |
53 ftp.retrlines( 'MLSD %s' % ( path ), path_contents.append ) | |
54 return [ line.split( ';' )[ -1 ].lstrip() for line in path_contents ] | |
55 | |
56 def _get_stream_readers_for_tar( file_obj, tmp_dir ): | |
57 fasta_tar = tarfile.open( fileobj=file_obj, mode='r:*' ) | |
58 return filter( lambda x: x is not None, [ fasta_tar.extractfile( member ) for member in fasta_tar.getmembers() ] ) | |
59 | |
60 def _get_stream_readers_for_zip( file_obj, tmp_dir ): | |
61 fasta_zip = zipfile.ZipFile( file_obj, 'r' ) | |
62 rval = [] | |
63 for member in fasta_zip.namelist(): | |
64 fasta_zip.extract( member, tmp_dir ) | |
65 rval.append( open( os.path.join( tmp_dir, member ), 'rb' ) ) | |
66 return rval | |
67 | |
68 def _get_stream_readers_for_gzip( file_obj, tmp_dir ): | |
69 return [ gzip.GzipFile( fileobj=file_obj, mode='rb' ) ] | |
70 | |
71 def _get_stream_readers_for_bz2( file_obj, tmp_dir ): | |
72 return [ bz2.BZ2File( file_obj.name, 'rb' ) ] | |
73 | |
74 def sort_fasta( fasta_filename, sort_method, params ): | |
75 if sort_method is None: | |
76 return | |
77 assert sort_method in SORTING_METHODS, ValueError( "%s is not a valid sorting option." % sort_method ) | |
78 return SORTING_METHODS[ sort_method ]( fasta_filename, params ) | |
79 | |
80 def _move_and_index_fasta_for_sorting( fasta_filename ): | |
81 unsorted_filename = tempfile.NamedTemporaryFile().name | |
82 shutil.move( fasta_filename, unsorted_filename ) | |
83 fasta_offsets = {} | |
84 unsorted_fh = open( unsorted_filename ) | |
85 while True: | |
86 offset = unsorted_fh.tell() | |
87 line = unsorted_fh.readline() | |
88 if not line: | |
89 break | |
90 if line.startswith( ">" ): | |
91 line = line.split( None, 1 )[0][1:] | |
92 fasta_offsets[ line ] = offset | |
93 unsorted_fh.close() | |
94 current_order = map( lambda x: x[1], sorted( map( lambda x: ( x[1], x[0] ), fasta_offsets.items() ) ) ) | |
95 return ( unsorted_filename, fasta_offsets, current_order ) | |
96 | |
97 def _write_sorted_fasta( sorted_names, fasta_offsets, sorted_fasta_filename, unsorted_fasta_filename ): | |
98 unsorted_fh = open( unsorted_fasta_filename ) | |
99 sorted_fh = open( sorted_fasta_filename, 'wb+' ) | |
100 | |
101 for name in sorted_names: | |
102 offset = fasta_offsets[ name ] | |
103 unsorted_fh.seek( offset ) | |
104 sorted_fh.write( unsorted_fh.readline() ) | |
105 while True: | |
106 line = unsorted_fh.readline() | |
107 if not line or line.startswith( ">" ): | |
108 break | |
109 sorted_fh.write( line ) | |
110 unsorted_fh.close() | |
111 sorted_fh.close() | |
112 | |
113 def _sort_fasta_as_is( fasta_filename, params ): | |
114 return | |
115 | |
116 def _sort_fasta_lexicographical( fasta_filename, params ): | |
117 ( unsorted_filename, fasta_offsets, current_order ) = _move_and_index_fasta_for_sorting( fasta_filename ) | |
118 sorted_names = sorted( fasta_offsets.keys() ) | |
119 if sorted_names == current_order: | |
120 shutil.move( unsorted_filename, fasta_filename ) | |
121 else: | |
122 _write_sorted_fasta( sorted_names, fasta_offsets, fasta_filename, unsorted_filename ) | |
123 | |
124 def _sort_fasta_gatk( fasta_filename, params ): | |
125 #This method was added by reviewer request. | |
126 ( unsorted_filename, fasta_offsets, current_order ) = _move_and_index_fasta_for_sorting( fasta_filename ) | |
127 sorted_names = map( str, range( 1, 23 ) ) + [ 'X', 'Y' ] | |
128 #detect if we have chrN, or just N | |
129 has_chr = False | |
130 for chrom in sorted_names: | |
131 if "chr%s" % chrom in current_order: | |
132 has_chr = True | |
133 break | |
134 | |
135 if has_chr: | |
136 sorted_names = map( lambda x: "chr%s" % x, sorted_names) | |
137 sorted_names.insert( 0, "chrM" ) | |
138 else: | |
139 sorted_names.insert( 0, "MT" ) | |
140 sorted_names.extend( map( lambda x: "%s_random" % x, sorted_names ) ) | |
141 | |
142 existing_sorted_names = [] | |
143 for name in sorted_names: | |
144 if name in current_order: | |
145 existing_sorted_names.append( name ) | |
146 for name in current_order: | |
147 #TODO: confirm that non-canonical names do not need to be sorted specially | |
148 if name not in existing_sorted_names: | |
149 existing_sorted_names.append( name ) | |
150 | |
151 if existing_sorted_names == current_order: | |
152 shutil.move( unsorted_filename, fasta_filename ) | |
153 else: | |
154 _write_sorted_fasta( existing_sorted_names, fasta_offsets, fasta_filename, unsorted_filename ) | |
155 | |
156 def _sort_fasta_custom( fasta_filename, params ): | |
157 ( unsorted_filename, fasta_offsets, current_order ) = _move_and_index_fasta_for_sorting( fasta_filename ) | |
158 sorted_names = [] | |
159 for id_repeat in params['param_dict']['sorting']['sequence_identifiers']: | |
160 sorted_names.append( id_repeat[ 'identifier' ] ) | |
161 handle_not_listed = params['param_dict']['sorting']['handle_not_listed']['handle_not_listed_selector'] | |
162 if handle_not_listed.startswith( 'keep' ): | |
163 add_list = [] | |
164 for name in current_order: | |
165 if name not in sorted_names: | |
166 add_list.append( name ) | |
167 if add_list: | |
168 if handle_not_listed == 'keep_append': | |
169 sorted_names.extend( add_list ) | |
170 else: | |
171 add_list.extend( sorted_names ) | |
172 sorted_names = add_list | |
173 if sorted_names == current_order: | |
174 shutil.move( unsorted_filename, fasta_filename ) | |
175 else: | |
176 _write_sorted_fasta( sorted_names, fasta_offsets, fasta_filename, unsorted_filename ) | |
177 | |
178 def download_from_ucsc( data_manager_dict, params, target_directory, dbkey, dbkey_name, sequence_id, sequence_name ): | |
179 UCSC_FTP_SERVER = 'hgdownload.cse.ucsc.edu' | |
180 UCSC_DOWNLOAD_PATH = '/goldenPath/%s/bigZips/' | |
181 COMPRESSED_EXTENSIONS = [ ( '.tar.gz', _get_stream_readers_for_tar ), ( '.tar.bz2', _get_stream_readers_for_tar ), ( '.zip', _get_stream_readers_for_zip ), ( '.fa.gz', _get_stream_readers_for_gzip ), ( '.fa.bz2', _get_stream_readers_for_bz2 ) ] | |
182 | |
183 email = params['param_dict']['__user_email__'] | |
184 if not email: | |
185 email = 'anonymous@example.com' | |
186 | |
187 ucsc_dbkey = params['param_dict']['reference_source']['requested_dbkey'] or dbkey | |
188 UCSC_CHROM_FA_FILENAMES = [ '%s.chromFa' % ucsc_dbkey, 'chromFa' ] | |
189 | |
190 ftp = FTP( UCSC_FTP_SERVER ) | |
191 ftp.login( 'anonymous', email ) | |
192 | |
193 ucsc_path = UCSC_DOWNLOAD_PATH % ucsc_dbkey | |
194 path_contents = _get_files_in_ftp_path( ftp, ucsc_path ) | |
195 | |
196 ucsc_file_name = None | |
197 get_stream_reader = None | |
198 ext = None | |
199 ucsc_chrom_fa_filename = None | |
200 for ucsc_chrom_fa_filename in UCSC_CHROM_FA_FILENAMES: | |
201 for ext, get_stream_reader in COMPRESSED_EXTENSIONS: | |
202 if "%s%s" % ( ucsc_chrom_fa_filename, ext ) in path_contents: | |
203 ucsc_file_name = "%s%s%s" % ( ucsc_path, ucsc_chrom_fa_filename, ext ) | |
204 break | |
205 if ucsc_file_name: | |
206 break | |
207 | |
208 if not ucsc_file_name: | |
209 raise Exception( 'Unable to determine filename for UCSC Genome for %s: %s' % ( ucsc_dbkey, path_contents ) ) | |
210 | |
211 | |
212 tmp_dir = tempfile.mkdtemp( prefix='tmp-data-manager-ucsc-' ) | |
213 ucsc_fasta_filename = os.path.join( tmp_dir, "%s%s" % ( ucsc_chrom_fa_filename, ext ) ) | |
214 | |
215 fasta_base_filename = "%s.fa" % sequence_id | |
216 fasta_filename = os.path.join( target_directory, fasta_base_filename ) | |
217 fasta_writer = open( fasta_filename, 'wb+' ) | |
218 | |
219 tmp_extract_dir = os.path.join ( tmp_dir, 'extracted_fasta' ) | |
220 os.mkdir( tmp_extract_dir ) | |
221 | |
222 tmp_fasta = open( ucsc_fasta_filename, 'wb+' ) | |
223 | |
224 ftp.retrbinary( 'RETR %s' % ucsc_file_name, tmp_fasta.write ) | |
225 | |
226 tmp_fasta.flush() | |
227 tmp_fasta.seek( 0 ) | |
228 | |
229 fasta_readers = get_stream_reader( tmp_fasta, tmp_extract_dir ) | |
230 | |
231 for data_table_name, data_table_entry in _stream_fasta_to_file( fasta_readers, target_directory, dbkey, dbkey_name, sequence_id, sequence_name, params ): | |
232 if data_table_entry: | |
233 _add_data_table_entry( data_manager_dict, data_table_entry, data_table_name ) | |
234 | |
235 for fasta_reader in fasta_readers: | |
236 fasta_reader.close() | |
237 tmp_fasta.close() | |
238 cleanup_before_exit( tmp_dir ) | |
239 | |
240 def download_from_ncbi( data_manager_dict, params, target_directory, dbkey, dbkey_name, sequence_id, sequence_name ): | |
241 NCBI_DOWNLOAD_URL = 'http://togows.dbcls.jp/entry/ncbi-nucleotide/%s.fasta' #FIXME: taken from dave's genome manager...why some japan site? | |
242 | |
243 requested_identifier = params['param_dict']['reference_source']['requested_identifier'] | |
244 url = NCBI_DOWNLOAD_URL % requested_identifier | |
245 fasta_readers = urllib2.urlopen( url ) | |
246 | |
247 for data_table_name, data_table_entry in _stream_fasta_to_file( fasta_readers, target_directory, dbkey, dbkey_name, sequence_id, sequence_name, params ): | |
248 if data_table_entry: | |
249 _add_data_table_entry( data_manager_dict, data_table_entry, data_table_name ) | |
250 | |
251 def download_from_url( data_manager_dict, params, target_directory, dbkey, dbkey_name, sequence_id, sequence_name ): | |
252 #TODO: we should automatically do decompression here | |
253 urls = filter( bool, map( lambda x: x.strip(), params['param_dict']['reference_source']['user_url'].split( '\n' ) ) ) | |
254 fasta_readers = [ urllib2.urlopen( url ) for url in urls ] | |
255 | |
256 for data_table_name, data_table_entry in _stream_fasta_to_file( fasta_readers, target_directory, dbkey, dbkey_name, sequence_id, sequence_name, params ): | |
257 if data_table_entry: | |
258 _add_data_table_entry( data_manager_dict, data_table_entry, data_table_name ) | |
259 | |
260 def download_from_history( data_manager_dict, params, target_directory, dbkey, dbkey_name, sequence_id, sequence_name ): | |
261 #TODO: allow multiple FASTA input files | |
262 input_filename = params['param_dict']['reference_source']['input_fasta'] | |
263 if isinstance( input_filename, list ): | |
264 fasta_readers = [ open( filename, 'rb' ) for filename in input_filename ] | |
265 else: | |
266 fasta_readers = open( input_filename ) | |
267 | |
268 for data_table_name, data_table_entry in _stream_fasta_to_file( fasta_readers, target_directory, dbkey, dbkey_name, sequence_id, sequence_name, params ): | |
269 if data_table_entry: | |
270 _add_data_table_entry( data_manager_dict, data_table_entry, data_table_name ) | |
271 | |
272 def copy_from_directory( data_manager_dict, params, target_directory, dbkey, dbkey_name, sequence_id, sequence_name ): | |
273 input_filename = params['param_dict']['reference_source']['fasta_filename'] | |
274 create_symlink = params['param_dict']['reference_source']['create_symlink'] == 'create_symlink' | |
275 if create_symlink: | |
276 data_table_entries = _create_symlink( input_filename, target_directory, dbkey, dbkey_name, sequence_id, sequence_name ) | |
277 else: | |
278 if isinstance( input_filename, list ): | |
279 fasta_readers = [ open( filename, 'rb' ) for filename in input_filename ] | |
280 else: | |
281 fasta_readers = open( input_filename ) | |
282 data_table_entries = _stream_fasta_to_file( fasta_readers, target_directory, dbkey, dbkey_name, sequence_id, sequence_name, params ) | |
283 for data_table_name, data_table_entry in data_table_entries: | |
284 if data_table_entry: | |
285 _add_data_table_entry( data_manager_dict, data_table_entry, data_table_name ) | |
286 | |
287 def _add_data_table_entry( data_manager_dict, data_table_entry, data_table_name ): | |
288 data_manager_dict['data_tables'] = data_manager_dict.get( 'data_tables', {} ) | |
289 data_manager_dict['data_tables'][data_table_name] = data_manager_dict['data_tables'].get( 'all_fasta', [] ) | |
290 data_manager_dict['data_tables'][data_table_name].append( data_table_entry ) | |
291 return data_manager_dict | |
292 | |
293 def _stream_fasta_to_file( fasta_stream, target_directory, dbkey, dbkey_name, sequence_id, sequence_name, params, close_stream=True ): | |
294 fasta_base_filename = "%s.fa" % sequence_id | |
295 fasta_filename = os.path.join( target_directory, fasta_base_filename ) | |
296 fasta_writer = open( fasta_filename, 'wb+' ) | |
297 | |
298 if isinstance( fasta_stream, list ) and len( fasta_stream ) == 1: | |
299 fasta_stream = fasta_stream[0] | |
300 | |
301 if isinstance( fasta_stream, list ): | |
302 last_char = None | |
303 for fh in fasta_stream: | |
304 if last_char not in [ None, '\n', '\r' ]: | |
305 fasta_writer.write( '\n' ) | |
306 while True: | |
307 data = fh.read( CHUNK_SIZE ) | |
308 if data: | |
309 fasta_writer.write( data ) | |
310 last_char = data[-1] | |
311 else: | |
312 break | |
313 if close_stream: | |
314 fh.close() | |
315 else: | |
316 while True: | |
317 data = fasta_stream.read( CHUNK_SIZE ) | |
318 if data: | |
319 fasta_writer.write( data ) | |
320 else: | |
321 break | |
322 if close_stream: | |
323 fasta_stream.close() | |
324 | |
325 fasta_writer.close() | |
326 | |
327 sort_fasta( fasta_filename, params['param_dict']['sorting']['sort_selector'], params ) | |
328 | |
329 dbkey_dict = None | |
330 if dbkey_name: | |
331 #do len calc here | |
332 len_base_name = "%s.len" % ( dbkey ) | |
333 compute_fasta_length( fasta_filename, os.path.join( target_directory, len_base_name ), keep_first_word=True ) | |
334 dbkey_dict = dict( value=dbkey, name=dbkey_name, len_path=len_base_name ) | |
335 | |
336 return [ ( '__dbkeys__', dbkey_dict ), ( 'all_fasta', dict( value=sequence_id, dbkey=dbkey, name=sequence_name, path=fasta_base_filename ) ) ] | |
337 | |
338 def compute_fasta_length( fasta_file, out_file, keep_first_word=False ): | |
339 | |
340 infile = fasta_file | |
341 out = open( out_file, 'w') | |
342 | |
343 fasta_title = '' | |
344 seq_len = 0 | |
345 | |
346 first_entry = True | |
347 | |
348 for line in open( infile ): | |
349 line = line.strip() | |
350 if not line or line.startswith( '#' ): | |
351 continue | |
352 if line[0] == '>': | |
353 if first_entry == False: | |
354 if keep_first_word: | |
355 fasta_title = fasta_title.split()[0] | |
356 out.write( "%s\t%d\n" % ( fasta_title[ 1: ], seq_len ) ) | |
357 else: | |
358 first_entry = False | |
359 fasta_title = line | |
360 seq_len = 0 | |
361 else: | |
362 seq_len += len(line) | |
363 | |
364 # last fasta-entry | |
365 if keep_first_word: | |
366 fasta_title = fasta_title.split()[0] | |
367 out.write( "%s\t%d\n" % ( fasta_title[ 1: ], seq_len ) ) | |
368 out.close() | |
369 | |
370 def _create_symlink( input_filename, target_directory, dbkey, dbkey_name, sequence_id, sequence_name ): | |
371 fasta_base_filename = "%s.fa" % sequence_id | |
372 fasta_filename = os.path.join( target_directory, fasta_base_filename ) | |
373 os.symlink( input_filename, fasta_filename ) | |
374 | |
375 dbkey_dict = None | |
376 if dbkey_name: | |
377 #do len calc here | |
378 len_base_name = "%s.len" % ( dbkey ) | |
379 compute_fasta_length( fasta_filename, os.path.join( target_directory, len_base_name ), keep_first_word=True ) | |
380 dbkey_dict = dict( value=dbkey, name=dbkey_name, len_path=len_base_name ) | |
381 | |
382 return [ ( '__dbkeys__', dbkey_dict ), ( 'all_fasta', dict( value=sequence_id, dbkey=dbkey, name=sequence_name, path=fasta_base_filename ) ) ] | |
383 | |
384 | |
385 | |
386 | |
387 REFERENCE_SOURCE_TO_DOWNLOAD = dict( ucsc=download_from_ucsc, ncbi=download_from_ncbi, url=download_from_url, history=download_from_history, directory=copy_from_directory ) | |
388 | |
389 SORTING_METHODS = dict( as_is=_sort_fasta_as_is, lexicographical=_sort_fasta_lexicographical, gatk=_sort_fasta_gatk, custom=_sort_fasta_custom ) | |
390 | |
391 def main(): | |
392 #Parse Command Line | |
393 parser = optparse.OptionParser() | |
394 parser.add_option( '-d', '--dbkey_description', dest='dbkey_description', action='store', type="string", default=None, help='dbkey_description' ) | |
395 (options, args) = parser.parse_args() | |
396 | |
397 filename = args[0] | |
398 | |
399 params = loads( open( filename ).read() ) | |
400 target_directory = params[ 'output_data' ][0]['extra_files_path'] | |
401 os.mkdir( target_directory ) | |
402 data_manager_dict = {} | |
403 | |
404 dbkey, dbkey_name, sequence_id, sequence_name = get_dbkey_dbname_id_name( params, dbkey_description=options.dbkey_description ) | |
405 | |
406 if dbkey in [ None, '', '?' ]: | |
407 raise Exception( '"%s" is not a valid dbkey. You must specify a valid dbkey.' % ( dbkey ) ) | |
408 | |
409 #Fetch the FASTA | |
410 REFERENCE_SOURCE_TO_DOWNLOAD[ params['param_dict']['reference_source']['reference_source_selector'] ]( data_manager_dict, params, target_directory, dbkey, dbkey_name, sequence_id, sequence_name ) | |
411 | |
412 #save info to json file | |
413 open( filename, 'wb' ).write( dumps( data_manager_dict ) ) | |
414 | |
415 if __name__ == "__main__": main() |