Package csb :: Package apps :: Module buildhmm

[frames] | no frames]

# Source Code for Module csb.apps.buildhmm

      1  """
      2  Build an HMM from a FASTA sequence. This program is a proxy to hhblits/addss.pl
      3  and hhmake from the HHpred package.
      4
      5  @note: assuming you have the full HHpred package installed and configured.
      6  """
      7
      8
      9  import os
     10  import abc
     11
     12  import csb.apps
     13  import csb.core
     14  import csb.io
     15
     16  from csb.bio.io.wwpdb import StructureParser
     17  from csb.bio.io.hhpred import HHProfileParser
     18  from csb.bio.io.fasta import FASTAOutputBuilder
     19  from csb.bio.sequence import ChainSequence
     20
     21
     22
     23 -class ExitCodes(csb.apps.ExitCodes):
     24
     25      IO_ERROR = 2
     26      INVALID_DATA = 3
     27      EXT_TOOL_FAILURE = 4
     28
     29 -class AppRunner(csb.apps.AppRunner):
     30
     31      @property
     32 -    def target(self):
     33          return BuildProfileApp
     34
     35 -    def command_line(self):
     36
     37          cmd = csb.apps.ArgHandler(self.program, __doc__)
     38
     39          cmd.add_scalar_option('query-id', 'q', str, 'ID of the query, in PDB-like format (accessionCHAIN).'
     40                                'Used for naming the output files. Also, if the input is a PDB file with '
     41                                'multiple chains, CHAIN is used to pull the required chain from the file.',
     42                                required=True)
     43          cmd.add_scalar_option('tk-root', 't', str, 'path to the ToolkitRoot folder in your HHsuite setup', default='/ebio/abt1_toolkit/share/wye')
     44          cmd.add_scalar_option('database', 'd', str, 'custom HHblits database; if not defined, toolkit\'s unirpto20 will be used', default=None)
     45          cmd.add_scalar_option('tk-config', 'c', str, 'path to a folder containing custom HHsuite configs (e.g. HHPaths.pm)', default='.')
     46          cmd.add_scalar_option('cpu', None, int, 'maximum degree of parallelism', default=1)
     47
     48          cmd.add_boolean_option('no-ss', None, 'do not include secondary structure', default=False)
     49          cmd.add_boolean_option('no-pseudo', None, 'do not add emission and transition pseudocounts', default=False)
     50          cmd.add_boolean_option('no-calibration', None, 'do not calibrate the profile', default=False)
     51
     52          cmd.add_positional_argument('query', str, 'input sequence (FASTA or PDB file)')
     53
     54          return cmd
     55
     56
     57 -class BuildProfileApp(csb.apps.Application):
     58
     59 -    def main(self):
     60
     61          if os.path.isfile(self.args.query_id + '.hhm'):
     62              BuildProfileApp.exit('# Profile "{0}" already exists, skipping'.format(self.args.query_id),
     63                                   ExitCodes.CLEAN)
     64
     65          try:
     66              self.log('# Building profile HMM for {0}...'.format(self.args.query))
     67              pb = ProfileBuilder.create(self.args.query, self.args.query_id, self.args.database, self.args.tk_root, self.args.tk_config,
     68                                         pseudo=not self.args.no_pseudo, ss=not self.args.no_ss, cpu=self.args.cpu)
     69
     70              pb.build_alignment()
     71              pb.make_hmm()
     72
     73              if not self.args.no_calibration:
     74                  pb.calibrate_hmm()
     75
     76          except BuildArgError as ae:
     77              BuildProfileApp.exit(str(ae), ExitCodes.INVALID_DATA)
     78
     79          except BuildIOError as ioe:
     80              BuildProfileApp.exit(str(ioe), ExitCodes.IO_ERROR)
     81
     82          except csb.io.InvalidCommandError as ose:
     83              msg = '{0!s}: {0.cmd}'.format(ose)
     84              BuildProfileApp.exit(msg, ExitCodes.IO_ERROR)
     85
     86          except NoOutputError as noe:
     87              msg = 'Expected file {0} not produced by: {1.cmd}.\nSTDERR: {1.stderr}\nSTDOUT: {1.stdout}'.format(noe.expected, noe.context)
     88              BuildProfileApp.exit(msg, ExitCodes.EXT_TOOL_FAILURE)
     89
     90          except csb.io.ProcessError as pe:
     91              msg = 'Bad exit code #{0.code} from: {0.cmd}.\nSTDERR: {0.stderr}\nSTDOUT: {0.stdout}'.format(pe.context)
     92              BuildProfileApp.exit(msg, ExitCodes.EXT_TOOL_FAILURE)
     93
     94          self.log('  successfully created profile "{0}"'.format(self.args.query_id))
     95
     96
     97 -class BuildError(Exception):
     98      pass
     99
    100 -class BuildIOError(BuildError):
    101      pass
    102
    103 -class BuildArgError(BuildError):
    104      pass
    105
    106 -class NoOutputError(BuildError):
    107
    108 -    def __init__(self, expected, context, *args):
    109
    110          self.expected = expected
    111          self.context = context
    112          super(NoOutputError, self).__init__(*args)
    113
    114
    115 -class ProfileBuilder(object):
    116
    117      __metaclass__ = abc.ABCMeta
    118
    119      EMISSION_PSEUDO = '-pcm 4 -pca 2.5 -pcb 0.5 -pcc 1.0'
    120      TRANSITION_PSEUDO = '-gapb 1.0 -gapd 0.15 -gape 1.0 -gapf 0.6 -gapg 0.6 -gapi 0.6'
    121
    122      @staticmethod
    123 -    def create(query, target_id, database, tk_root, tk_config, pseudo=True, ss=True, cpu=1):
    124
    125          if database is None:
    126              database = os.path.join(tk_root, "databases", "hhblits", "uniprot20")
    127
    128          if not os.path.isfile(query):
    129              raise BuildIOError('File not found: ' + query)
    130
    131          for line in open(query):
    132
    133              if not line.strip():
    134                  continue
    135
    136              if line.startswith('>'):
    137                  return FASTAProfileBuilder(query, target_id, database, tk_root, tk_config, pseudo, ss, cpu)
    138              elif line.startswith('HEADER') or line.startswith('ATOM'):
    139                  return PDBProfileBuilder(query, target_id, database, tk_root, tk_config, pseudo, ss, cpu)
    140              else:
    141                  raise BuildArgError('Unknown input file format')
    142
    143 -    def __init__(self, query, target_id, database, tk_root, tk_config, pseudo=True, ss=True, cpu=1):
    144
    145          self.tk_root = tk_root
    146          self.tk_config = tk_config
    147          self.hhlib = os.path.join(tk_root, "bioprogs", "hhsuite")
    148
    149          if 'TK_ROOT' not in os.environ or not os.environ['TK_ROOT']:
    150              os.putenv('TK_ROOT', self.tk_root)
    151          if 'HHLIB' not in os.environ or not os.environ['HHLIB']:
    152              os.putenv('HHLIB', self.hhlib)
    153          os.environ["PATH"] += os.pathsep + os.path.join(self.hhlib, "bin")
    154
    155          self.query = query
    156          self.accession = target_id[:-1]
    157          self.chain = target_id[-1]
    158          self.database = database
    159          self.pseudo = bool(pseudo)
    160          self.ss = bool(ss)
    161          self.cpu = cpu
    162
    163          self._input = None
    164          self._a3m = None
    165          self._hhm = None
    166
    167          self.configure_input()
    168
    169 -    def run(self):
    170
    171          self.build_alignment()
    172          self.make_hmm()
    173          self.calibrate_hmm()
    174
    175      @property
    176 -    def target_id(self):
    177          return self.accession + self.chain
    178
    179      @abc.abstractmethod
    180 -    def configure_input(self):
    181          pass
    182
    183 -    def build_alignment(self):
    184          assert self._input is not None
    185
    186          program = os.path.join(self.tk_root, 'bioprogs', 'hhsuite', 'bin', 'hhblits')
    187
    188          ali = self.target_id + '.a3m'
    189          cmd = '{0} -cpu {1} -i {2} -d {3} -nodiff -oa3m {4}'.format(
    190                                  program, self.cpu, self._input, self.database, ali)
    191          bali = csb.io.Shell.run(cmd)
    192
    193          if bali.code != 0:
    194              raise csb.io.ProcessError(bali)
    195          if not os.path.isfile(ali):
    196              raise NoOutputError(ali, bali)
    197
    198          if self.ss:
    199              program2 = os.path.join(self.tk_root, 'bioprogs', 'hhsuite', 'scripts', 'addss.pl')
    200
    201              with csb.io.TempFile() as patch:
    202                  for l in open(program2):
    203                      if l.lstrip().startswith("use HHPaths"):
    204                          patch.write('use lib "{0}";\n'.format(self.tk_config))
    205                      patch.write(l);
    206                  patch.flush()
    207
    208                  cmd2 = "perl {0} {1}".format(patch.name, ali)
    209                  addss = csb.io.Shell.run(cmd2)
    210                  if addss.code != 0:
    211                      raise csb.io.ProcessError(addss)
    212
    213          self._ali = ali
    214          return ali
    215
    216 -    def make_hmm(self):
    217          assert self._ali is not None
    218
    219          program = os.path.join(self.tk_root, 'bioprogs', 'hhpred', 'hhmake')
    220          hhm = self.target_id + '.hhm'
    221          cmd = '{0} -i {1} -o {2}'.format(program, self._ali, hhm)
    222
    223          if self.pseudo:
    224              cmd = '{0} {1} {2}'.format(cmd, ProfileBuilder.EMISSION_PSEUDO, ProfileBuilder.TRANSITION_PSEUDO)
    225
    226          nnmake = csb.io.Shell.run(cmd)
    227          if nnmake.code != 0:
    228              raise csb.io.ProcessError(nnmake)
    229          if not os.path.isfile(hhm):
    230              raise NoOutputError(hhm, nnmake)
    231
    232          self._hhm = hhm
    233          return hhm
    234
    235 -    def calibrate_hmm(self):
    236          assert self._hhm is not None
    237
    238          program = os.path.join(self.tk_root, 'bioprogs', 'hhpred', 'hhsearch')
    239          caldb = os.path.join(self.tk_root, 'databases', 'hhpred', 'cal.hhm')
    240
    241          cmd = '{0} -i {1}.hhm -d {2} -cal -cpu {3}'.format(program, self.target_id, caldb, self.cpu)
    242          csb.io.Shell.runstrict(cmd)
    243
    244
    245 -class FASTAProfileBuilder(ProfileBuilder):
    246
    247 -    def configure_input(self):
    248
    249          if not os.path.isfile(self.query):
    250              raise BuildIOError('File not found: ' + self.query)
    251
    252          fasta = self.target_id + '.fa'
    253
    254          with csb.io.EntryWriter(fasta) as f:
    255              with open(self.query) as q:
    256                  f.write(q.read())
    257
    258          self._input = fasta
    259          return fasta
    260
    261
    262 -class PDBProfileBuilder(ProfileBuilder):
    263
    264 -    def configure_input(self):
    265
    266          try:
    267              s = StructureParser(self.query).parse()
    268              chain = s.chains[self.chain]
    269          except csb.core.ItemNotFoundError:
    270              raise BuildArgError('Chain {0.chain} not found in {0.query}'.format(self))
    271          except IOError as ioe:
    272              raise BuildIOError(str(ioe))
    273
    274          fasta = self.target_id + '.fa'
    275
    276          with open(fasta, 'w') as f:
    277              sequence = ChainSequence.create(chain)
    278              FASTAOutputBuilder(f).add_sequence(sequence)
    279
    280          self._input = fasta
    281          return fasta
    282
    283 -    def make_hmm(self):
    284
    285          super(PDBProfileBuilder, self).make_hmm()
    286          self.format_structure()
    287
    288 -    def format_structure(self):
    289          assert self._hhm is not None
    290
    291          pdb = self.target_id + '.pdb'
    292
    293          parser = HHProfileParser(self._hhm)
    294          parser.format_structure(self.query, self.chain, pdb)
    295
    296          self._pdb = pdb
    297          return pdb
    298
    299
    300 -def main():
    301      AppRunner().run()
    302
    303
    304  if __name__ == '__main__':
    305      main()
    306