Debian Codegraph @

csb/apps/hhsearch.py

raw ◀ ▶
Source reconstructed at patch state 0 of 1 — not the installed (fully patched) source.
1 Debian patch touch this file
1 """
2 Python bindings for the HHsearch program. Capable of executing multiple
3 HHsearch jobs in parallel.
4 """
5
6 import multiprocessing as mp
7
8 import csb.apps
9 import csb.io
10 import csb.bio.io
11
12
13 class ExitCodes(csb.apps.ExitCodes):
14
15 IO_ERROR = 2
16 INVALID_DATA = 3
17 EXT_TOOL_FAILURE = 4
18
19
20 class AppRunner(csb.apps.AppRunner):
21
22 @property
23 def target(self):
24 return HHsearchApp
25
26 def command_line(self):
27
28 cpu = mp.cpu_count()
29 cmd = csb.apps.ArgHandler(self.program, __doc__)
30
31 cmd.add_scalar_option('binary', 'b', str, 'full path to the HHsearch binary ', default='hhsearch')
32 cmd.add_scalar_option('cpu', 'c', int, 'maximum degree of parallelism', default=cpu)
33 cmd.add_scalar_option('database', 'd', str, 'the subject (database) HMM file', required=True)
34 cmd.add_array_argument('query', str, 'query HMM file(s)')
35
36 return cmd
37
38
39 class HHsearchApp(csb.apps.Application):
40
41 def main(self):
42
43 queries = list(self.args.query)
44 exe = HHsearch(self.args.binary, self.args.database)
45
46 try:
47 if len(queries) == 1:
48 exe.cpu = self.args.cpu
49 context = HHTask(queries[0])
50 results = [ exe.run(context) ]
51 else:
52 context = [ HHTask(q) for q in queries ]
53 results = exe.runmany(context, workers=self.args.cpu)
54
55 except IOError as io:
56 HHsearchApp.exit(str(io), ExitCodes.IO_ERROR)
57
58 except csb.io.InvalidCommandError as ose:
59 msg = '{0!s}: {0.program}'.format(ose)
60 HHsearchApp.exit(msg, ExitCodes.IO_ERROR)
61
62 except csb.io.ProcessError as pe:
63 message = 'Bad exit code from HHsearch: #{0.code}.\nSTDERR: {0.stderr}\nSTDOUT: {0.stdout}'.format(pe.context)
64 HHsearchApp.exit(message, ExitCodes.EXT_TOOL_FAILURE)
65
66 self.log('\nRank Hit Prob St End Qst Qend')
67 self.log('-------------------------------------')
68
69 for c in results:
70 self.log('\n\n# QUERY:{0}\n'.format(c.queryfile))
71 if c.result:
72 for hit in c.result:
73 self.log('{0.rank:3}. {0.id:5} {0.probability:5.3f} {0.start:3} {0.end:3} {0.qstart:3} {0.qend:3}'.format(hit))
74
75
76 class Context(object):
77
78 def __init__(self, query):
79
80 self.__query = query
81 self.__result = None
82
83 @property
84 def query(self):
85 return self.__query
86
87 @property
88 def result(self):
89 return self.__result
90 @result.setter
91 def result(self, result):
92 self.__result = result
93
94
95 class HHTask(Context):
96
97 def __init__(self, queryfile):
98
99 self.queryfile = queryfile
100 query = open(queryfile).read()
101
102 super(HHTask, self).__init__(query)
103
104
105 def _task(args):
106
107 try:
108 binary, db, cpu, context = args
109 return HHsearch(binary, db, cpu=cpu).run(context)
110 except (KeyboardInterrupt, SystemExit):
111 return
112
113 class SecStructureScoring(object):
114
115 OFF = 0
116 AFTER = 1
117 DURING = 2
118 AFTER_PREDICTED = 3
119 DURING_PREDICTED = 4
120
121 class HHsearch(object):
122
123 class Options(object):
124
125 CPU = 'cpu'
126 SS = 'ssm'
127 MACT = 'mact'
128 MAX_HITS = 'Z'
129 MAX_ALI = 'B'
130 MAX_E = 'E'
131 MIN_P = 'p'
132
133 def __init__(self, binary, db, cpu=None):
134
135 self._program = binary
136 self._db = db
137 self._opt = {}
138 self._parser = csb.bio.io.HHOutputParser()
139
140 self.cpu = cpu
141 self.ss = None
142 self.mac_threshold = None
143 self.max_hits = None
144 self.max_alignments = None
145 self.max_evalue = None
146 self.min_probability = None
147
148 @property
149 def program(self):
150 return self._program
151 @program.setter
152 def program(self, value):
153 self._program = value
154
155 @property
156 def db(self):
157 return self._db
158 @db.setter
159 def db(self, value):
160 self._db = value
161
162 @property
163 def parser(self):
164 return self._parser
165 @parser.setter
166 def parser(self, value):
167 self._parser = value
168
169 @property
170 def cpu(self):
171 return self._get(HHsearch.Options.CPU)
172 @cpu.setter
173 def cpu(self, value):
174 self._opt[HHsearch.Options.CPU] = value
175
176 @property
177 def ss(self):
178 return self._get(HHsearch.Options.SS)
179 @ss.setter
180 def ss(self, value):
181 self._opt[HHsearch.Options.SS] = value
182
183 @property
184 def mac_threshold(self):
185 return self._get(HHsearch.Options.MACT)
186 @mac_threshold.setter
187 def mac_threshold(self, value):
188 self._opt[HHsearch.Options.MACT] = value
189
190 @property
191 def max_hits(self):
192 return self._get(HHsearch.Options.MAX_HITS)
193 @max_hits.setter
194 def max_hits(self, value):
195 self._opt[HHsearch.Options.MAX_HITS] = value
196
197 @property
198 def max_alignments(self):
199 return self._get(HHsearch.Options.MAX_ALI)
200 @max_alignments.setter
201 def max_alignments(self, value):
202 self._opt[HHsearch.Options.MAX_ALI] = value
203
204 @property
205 def max_evalue(self):
206 return self._get(HHsearch.Options.MAX_E)
207 @max_evalue.setter
208 def max_evalue(self, value):
209 self._opt[HHsearch.Options.MAX_E] = value
210
211 @property
212 def min_probability(self):
213 return self._get(HHsearch.Options.MIN_P)
214 @min_probability.setter
215 def min_probability(self, value):
216 self._opt[HHsearch.Options.MIN_P] = value
217
218 def _get(self, option):
219
220 if option in self._opt:
221 return self._opt[option]
222 else:
223 return None
224
225 def _options(self):
226
227 options = []
228
229 for option in self._opt:
230 value = self._opt[option]
231
232 if value is not None and value != '':
233 if isinstance(value, bool):
234 options.append('-{0}'.format(option))
235 else:
236 options.append('-{0} {1}'.format(option, value))
237
238 return ' '.join(options)
239
240 def run(self, context):
241
242 with csb.io.TempFile() as q:
243
244 q.write(context.query)
245 q.flush()
246
247 with csb.io.TempFile() as o:
248
249 cmd = '{0.program} -i {1} -d {0.db} -o {2} {3}'.format(self, q.name, o.name, self._options())
250 csb.io.Shell.runstrict(cmd)
251
252 context.result = self.parser.parse_file(o.name)
253 return context
254
255 def runmany(self, contexts, workers=mp.cpu_count(), cpu=1):
256
257 if workers > len(contexts):
258 workers = len(contexts)
259
260 results = []
261 taskargs = [(self.program, self.db, cpu, c) for c in contexts]
262
263 pool = mp.Pool(workers)
264
265 try:
266 for c in pool.map(_task, taskargs):
267 results.append(c)
268 except KeyboardInterrupt:
269 pass
270 finally:
271 pool.terminate()
272
273 return results
274
275
276 def main():
277 AppRunner().run()
278
279
280 if __name__ == '__main__':
281 main()