| 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, cpu=1): |
| 256 |
|
| 257 |
if not workers: |
| 258 |
workers = mp.cpu_count() |
| 259 |
|
| 260 |
if workers > len(contexts): |
| 261 |
workers = len(contexts) |
| 262 |
|
| 263 |
results = [] |
| 264 |
taskargs = [(self.program, self.db, cpu, c) for c in contexts] |
| 265 |
|
| 266 |
pool = mp.Pool(workers) |
| 267 |
|
| 268 |
try: |
| 269 |
for c in pool.map(_task, taskargs): |
| 270 |
results.append(c) |
| 271 |
except KeyboardInterrupt: |
| 272 |
pass |
| 273 |
finally: |
| 274 |
pool.terminate() |
| 275 |
|
| 276 |
return results |
| 277 |
|
| 278 |
|
| 279 |
def main(): |
| 280 |
AppRunner().run() |
| 281 |
|
| 282 |
|
| 283 |
if __name__ == '__main__': |
| •284 |
main() |