|
3
|
1 from bl.core.io.illumina import GenomeStudioSampleSheetReader as gsr
|
|
|
2 from bl.vl.utils import LOG_LEVELS, get_logger
|
|
|
3 import csv, argparse, sys, re
|
|
|
4
|
|
|
5
|
|
|
6 def make_parser():
|
|
|
7 parser = argparse.ArgumentParser('Split GenomeStudio samplesheet in TSV files to import data within OMERO')
|
|
|
8 parser.add_argument('--logfile', type=str, help='log file (default=stderr)')
|
|
|
9 parser.add_argument('--loglevel', type=str, choices=LOG_LEVELS,
|
|
|
10 help='logging level', default='INFO')
|
|
|
11 parser.add_argument('--input-file', type=str, required=True,
|
|
|
12 help='GenomeStudio samplesheet')
|
|
|
13 parser.add_argument('--arrays-out-file', type=str,
|
|
|
14 help='output file containing IlluminaArrayOfArrays definitions',
|
|
|
15 default='./array_of_arrays.tsv')
|
|
|
16 parser.add_argument('--bead-chip-out-file', type=str,
|
|
|
17 help='output file containing IlluminaBeadChipArray definitions',
|
|
|
18 default='./bead_chip.tsv')
|
|
|
19 parser.add_argument('--array-measure-out-file', type=str,
|
|
|
20 help='output file containing IlluminaBeadChipMeasure definitions',
|
|
|
21 default='./array_measure.tsv')
|
|
|
22 parser.add_argument('--array-measures-out-file', type=str,
|
|
|
23 help='output file containing IlluminaBeadChipMeasures definitions',
|
|
|
24 default='./array_measures.tsv')
|
|
|
25 parser.add_argument('--study', type=str, required=True,
|
|
|
26 help='Study label that will be used in the import procedure')
|
|
|
27 return parser
|
|
|
28
|
|
|
29
|
|
|
30 def get_assay_type_enum(manifest_file):
|
|
|
31 return manifest_file.strip().replace('.bpm', '').replace('-', '_').replace(' ', '_').upper()
|
|
|
32
|
|
|
33
|
|
|
34 def prepare_array_of_arrays_input(barcode, study, elements):
|
|
|
35 ICHIPCORDS_PATTERN = re.compile(r'^r(\d{2})c(\d{2})$', re.IGNORECASE)
|
|
|
36 rows = []
|
|
|
37 cols = []
|
|
|
38 for x in elements:
|
|
|
39 m = re.match(ICHIPCORDS_PATTERN, x['array_label'])
|
|
|
40 rows.append(int(m.groups()[0]))
|
|
|
41 cols.append(int(m.groups()[1]))
|
|
|
42 return {
|
|
|
43 'barcode': barcode,
|
|
|
44 'rows': max(rows),
|
|
|
45 'columns': max(cols),
|
|
|
46 'label': barcode,
|
|
|
47 'study': study,
|
|
|
48 }
|
|
|
49
|
|
|
50
|
|
|
51 def barcodes_to_labels(elements, wells_map, strict_mapping, logger):
|
|
|
52 from copy import deepcopy
|
|
|
53
|
|
|
54 mapped_elements = []
|
|
|
55 for e in elements:
|
|
|
56 if e['source'] in wells_map:
|
|
|
57 new_el = deepcopy(e)
|
|
|
58 new_el['source'] = wells_map[e['source']]
|
|
|
59 mapped_elements.append(new_el)
|
|
|
60 else:
|
|
|
61 logger.warning('Unable to map well %s' % e['source'])
|
|
|
62
|
|
|
63 if strict_mapping and len(mapped_elements) < len(elements):
|
|
|
64 msg = 'Mapped %d records of %d' %(len(elements), len(mapped_elements))
|
|
|
65 logger.critical(msg)
|
|
|
66 sys.exit(msg)
|
|
|
67 return mapped_elements
|
|
|
68
|
|
|
69
|
|
|
70 def prepare_bead_chip_array_input(array_barcode, assay_type, study, elements):
|
|
|
71 return [{
|
|
|
72 'illumina_array': array_barcode,
|
|
|
73 'label': x['array_label'],
|
|
|
74 'source': x['source'],
|
|
|
75 'bead_chip_assay_type': assay_type,
|
|
|
76 'study': study,
|
|
|
77 } for x in elements]
|
|
|
78
|
|
|
79
|
|
|
80 def prepare_bead_chip_measure_input(array_barcode, study, elements,
|
|
|
81 device='generic_illumina_scanner',
|
|
|
82 status='USABLE'):
|
|
|
83 records = []
|
|
|
84 for channel in ['Grn', 'Red']:
|
|
|
85 records.extend(
|
|
|
86 [
|
|
|
87 {
|
|
|
88 'label': '%s_%s_%s' % (array_barcode, x['array_label'], channel),
|
|
|
89 'source': '%s:%s' % (array_barcode, x['array_label']),
|
|
|
90 'scanner': device,
|
|
|
91 'status': status,
|
|
|
92 'study': study,
|
|
|
93 } for x in elements
|
|
|
94 ]
|
|
|
95 )
|
|
|
96 return records
|
|
|
97
|
|
|
98
|
|
|
99 def prepare_bead_chip_array_measures_input(array_barcode, study, elements):
|
|
|
100 return [{
|
|
|
101 'study': study,
|
|
|
102 'label': '%s_%s' % (array_barcode, x['array_label']),
|
|
|
103 'red_channel': '%s_%s_Red' % (array_barcode, x['array_label']),
|
|
|
104 'green_channel': '%s_%s_Grn' %(array_barcode, x['array_label']),
|
|
|
105 'source': '%s:%s' % (array_barcode, x['array_label']),
|
|
|
106 } for x in elements]
|
|
|
107
|
|
|
108
|
|
|
109 def main(argv):
|
|
|
110 parser = make_parser()
|
|
|
111 args = parser.parse_args(argv)
|
|
|
112
|
|
|
113 logger = get_logger('prepare_illumina_import_inputs', level=args.loglevel,
|
|
|
114 filename=args.logfile)
|
|
|
115
|
|
|
116 logger.info('Processing file %s', args.input_file)
|
|
|
117 with open(args.input_file) as in_file:
|
|
|
118 reader = gsr(in_file)
|
|
|
119 assay_type = get_assay_type_enum(reader.header['A'])
|
|
|
120 arrays_map = {}
|
|
|
121 for r in reader:
|
|
|
122 arrays_map.setdefault(r['SentrixBarcode_A'], []).append({'source': r['Sample_ID'],
|
|
|
123 'array_label': r['SentrixPosition_A']})
|
|
|
124 with open(args.arrays_out_file, 'w') as array_file,\
|
|
|
125 open(args.bead_chip_out_file, 'w') as chip_file,\
|
|
|
126 open(args.array_measures_out_file, 'w') as measures_file,\
|
|
|
127 open(args.array_measure_out_file, 'w') as measure_file:
|
|
|
128 arrays_writer = csv.DictWriter(array_file,
|
|
|
129 ['study', 'label', 'barcode', 'rows', 'columns'],
|
|
|
130 delimiter='\t')
|
|
|
131 arrays_writer.writeheader()
|
|
|
132 chip_writer = csv.DictWriter(chip_file,
|
|
|
133 ['study', 'illumina_array', 'label', 'source',
|
|
|
134 'bead_chip_assay_type'],
|
|
|
135 delimiter='\t')
|
|
|
136 chip_writer.writeheader()
|
|
|
137 measure_writer = csv.DictWriter(measure_file,
|
|
|
138 ['study', 'label', 'source', 'scanner', 'status'],
|
|
|
139 delimiter='\t')
|
|
|
140 measure_writer.writeheader()
|
|
|
141 measures_writer = csv.DictWriter(measures_file,
|
|
|
142 ['study', 'label', 'red_channel', 'green_channel',
|
|
|
143 'source'],
|
|
|
144 delimiter='\t')
|
|
|
145 measures_writer.writeheader()
|
|
|
146 for k, v in arrays_map.iteritems():
|
|
|
147 arrays_writer.writerow(prepare_array_of_arrays_input(k, args.study, v))
|
|
|
148 chip_writer.writerows(prepare_bead_chip_array_input(k, assay_type, args.study, v))
|
|
|
149 measure_writer.writerows(prepare_bead_chip_measure_input(k, args.study, v))
|
|
|
150 measures_writer.writerows(prepare_bead_chip_array_measures_input(k, args.study, v))
|
|
|
151 logger.info('Job completed')
|
|
|
152
|
|
|
153
|
|
|
154 if __name__ == '__main__':
|
|
|
155 main(sys.argv[1:]) |
