wwood-bioruby 1.2.11

data/lib/bio/appl/blast/format8.rb

@@ -0,0 +1,83 @@
+#
+# = bio/appl/blast/format8.rb - BLAST tab-delimited output (-m 8) parser
+# 
+# Copyright::  Copyright (C) 2002, 2003, 2007 Toshiaki Katayama <k@bioruby.org>
+# License::    The Ruby License
+#
+# $Id:$
+#
+# == Note
+#
+# This file is automatically loaded by bio/appl/blast/report.rb
+#
+
+module Bio
+  class Blast
+    class Report
+
+      private
+
+      def tab_parse(data)
+        iteration = Iteration.new
+        @iterations.push(iteration)
+        @query_id = @query_def = data[/\S+/]
+
+        query_prev = ''
+        target_prev = ''
+        hit_num = 1
+        hsp_num = 1
+        hit = ''
+        data.each_line do |line|
+          ary = line.chomp.split("\t")
+          query_id, target_id, hsp = tab_parse_hsp(ary)
+          if query_prev != query_id or target_prev != target_id
+            hit = Hit.new
+            hit.num = hit_num
+            hit_num += 1
+            hit.query_id = hit.query_def = query_id
+            hit.accession = hit.definition = target_id
+            iteration.hits.push(hit)
+            hsp_num = 1
+          end
+          hsp.num = hsp_num
+          hsp_num += 1
+          hit.hsps.push(hsp)
+          query_prev = query_id
+          target_prev = target_id
+        end
+      end
+
+      def tab_parse_hsp(ary)
+        query_id, target_id,
+          percent_identity,
+          align_len,
+          mismatch_count,
+          gaps,
+          query_from,
+          query_to,
+          hit_from,
+          hit_to,
+          evalue,
+          bit_score = *ary
+
+        hsp = Hsp.new
+        hsp.align_len		= align_len.to_i
+        hsp.gaps		= gaps.to_i
+        hsp.query_from		= query_from.to_i
+        hsp.query_to		= query_to.to_i
+        hsp.hit_from		= hit_from.to_i
+        hsp.hit_to		= hit_to.to_i
+        hsp.evalue		= evalue.strip.to_f
+        hsp.bit_score		= bit_score.to_f
+
+        hsp.percent_identity	= percent_identity.to_f
+        hsp.mismatch_count	= mismatch_count.to_i
+
+        return query_id, target_id, hsp
+      end
+
+    end
+  end
+end
+
+

data/lib/bio/appl/blast/genomenet.rb

@@ -0,0 +1,263 @@
+#
+# = bio/appl/blast/genomenet.rb - Remote BLAST wrapper using GenomeNet
+# 
+# Copyright::  Copyright (C) 2001,2008  Mitsuteru C. Nakao <n@bioruby.org>
+# Copyright::  Copyright (C) 2002,2003  Toshiaki Katayama <k@bioruby.org>
+# Copyright::  Copyright (C) 2006       Jan Aerts <jan.aerts@bbsrc.ac.uk>
+# Copyright::  Copyright (C) 2008       Naohisa Goto <ng@bioruby.org>
+# License::    The Ruby License
+#
+# $Id:$
+#
+
+require 'net/http'
+require 'uri'
+require 'bio/command'
+require 'shellwords'
+require 'bio/appl/blast/remote'
+
+module Bio::Blast::Remote
+
+  # == Description
+  # 
+  # The Bio::Blast::Remote::GenomeNet class contains methods for running
+  # remote BLAST searches on GenomeNet (http://blast.genome.jp/).
+  #
+  # == Usage
+  #
+  #   require 'bio'
+  #   
+  #   # To run an actual BLAST analysis:
+  #   #   1. create a BLAST factory
+  #   blast_factory = Bio::Blast.remote('blastp', 'nr-aa',
+  #                                     '-e 0.0001', 'genomenet')
+  #   #or:
+  #   blast_factory = Bio::Blast::Remote.genomenet('blastp', 'nr-aa',
+  #                                                '-e 0.0001')
+  #
+  #   #   2. run the actual BLAST by querying the factory
+  #   report = blast_factory.query(sequence_text)
+  #
+  #   # Then, to parse the report, see Bio::Blast::Report
+  #
+  # === Available databases for Bio::Blast::Remote::GenomeNet
+  #
+  # Up-to-date available databases can be obtained by using
+  # Bio::Blast::Remote::GenomeNet.databases(program).
+  # Short descriptions of databases
+  #
+  #  ----------+-------+---------------------------------------------------
+  #   program  | query | db (supported in GenomeNet)
+  #  ----------+-------+---------------------------------------------------
+  #   blastp   | AA    | nr-aa, genes, vgenes.pep, swissprot, swissprot-upd,
+  #  ----------+-------+ pir, prf, pdbstr
+  #   blastx   | NA    | 
+  #  ----------+-------+---------------------------------------------------
+  #   blastn   | NA    | nr-nt, genbank-nonst, gbnonst-upd, dbest, dbgss,
+  #  ----------+-------+ htgs, dbsts, embl-nonst, embnonst-upd, epd,
+  #   tblastn  | AA    | genes-nt, genome, vgenes.nuc
+  #  ----------+-------+---------------------------------------------------
+  #
+  # == See also
+  #
+  # * Bio::Blast
+  # * Bio::Blast::Report
+  # * Bio::Blast::Report::Hit
+  # * Bio::Blast::Report::Hsp
+  #
+  # == References
+  # 
+  # * http://www.ncbi.nlm.nih.gov/blast/
+  # * http://www.ncbi.nlm.nih.gov/Education/BLASTinfo/similarity.html
+  # * http://blast.genome.jp/ideas/ideas.html#blast
+  #
+  module GenomeNet
+
+    Host = "blast.genome.jp".freeze
+
+    # Creates a remote BLAST factory using GenomeNet.
+    # Returns Bio::Blast object.
+    #
+    # Note for future improvement: In the future, it might return
+    # Bio::Blast::Remote::GenomeNet or other object. 
+    #
+    def self.new(program, db, options = [])
+      Bio::Blast.new(program, db, options, 'genomenet')
+    end
+
+    # Information for GenomeNet BLAST search.
+    module Information
+
+      include Bio::Blast::Remote::Information
+
+      # gets information from remote host and parses database information
+      def _parse_databases
+        if defined? @parse_databases
+          return nil if @parse_databases
+        end
+        databases = {}
+        dbdescs = {}
+        key = nil
+        host = Bio::Blast::Remote::Genomenet::Host
+        http = Bio::Command.new_http(host)
+        result = http.get('/')
+        #p result.body
+        result.body.each_line do |line|
+          case line
+          when /\"set\_dbtype\(this\.form\,\'(prot|nucl)\'\)\"/
+            key = $1
+            databases[key] ||= []
+            dbdescs[key] ||= {}
+          when /\<input *type\=\"radio\" *name\=\"dbname\" *value\=\"([^\"]+)\"[^\>]*\>([^\<\>]+)/
+            db = $1.freeze
+            desc = $2.strip.freeze
+            databases[key].push db
+            dbdescs[key][db] = desc
+          end
+        end
+
+        # mine-aa and mine-nt should be removed
+        [ 'prot', 'nucl' ].each do |mol|
+          ary  = databases[mol] || []
+          hash = dbdescs[mol] || {}
+          [ 'mine-aa', 'mine-nt' ].each do |k|
+            ary.delete(k)
+            hash.delete(k)
+          end
+          databases[mol] = ary.freeze
+          dbdescs[mol] = hash
+        end
+
+        [ databases, dbdescs ].each do |h|
+          prot = h['prot']
+          nucl = h['nucl']
+          h.delete('prot')
+          h.delete('nucl')
+          h['blastp'] = prot
+          h['blastx'] = prot
+          h['blastn']  = nucl
+          h['tblastn'] = nucl
+          h['tblastx'] = nucl
+        end
+
+        @databases = databases
+        @database_descriptions = dbdescs
+        @parse_databases = true
+        true
+      end
+      private :_parse_databases
+
+    end #module Information
+
+    extend Information
+
+    private
+
+    # executes BLAST and returns result as a string
+    def exec_genomenet(query)
+      host = Host
+      #host = "blast.genome.jp"
+      #path = "/sit-bin/nph-blast"
+      path = "/sit-bin/blast" #2005.08.12
+
+      options = make_command_line_options
+      opt = Bio::Blast::NCBIOptions.new(options)
+
+      program = opt.delete('-p')
+      db = opt.delete('-d')
+
+      matrix = opt.delete('-M') || 'blosum62'
+      filter = opt.delete('-F') || 'T'
+
+      opt_V = opt.delete('-V') || 500 # default value for GenomeNet
+      opt_B = opt.delete('-B') || 250 # default value for GenomeNet
+
+      # format, not for form parameters, but included in option string
+      opt_m = opt.get('-m') || '7' # default of BioRuby GenomeNet factory
+      opt.set('-m', opt_m)
+
+      optstr = Bio::Command.make_command_line_unix(opt.options)
+
+      form = {
+        'style'          => 'raw',
+        'prog'           => program,
+        'dbname'         => db,
+        'sequence'       => query,
+        'other_param'    => optstr,
+        'matrix'         => matrix,
+        'filter'         => filter,
+        'V_value'        => opt_V, 
+        'B_value'        => opt_B, 
+        'alignment_view' => 0,
+      }
+
+      form.keys.each do |k|
+        form.delete(k) unless form[k]
+      end
+
+      begin
+        http = Bio::Command.new_http(host)
+        http.open_timeout = 300
+        http.read_timeout = 600
+        result = Bio::Command.http_post_form(http, path, form)
+        @output = result.body
+
+        # workaround 2008.8.13
+        if result.code == '302' then
+          newuri = URI.parse(result['location'])
+          newpath = newuri.path
+          result = http.get(newpath)
+          @output = result.body
+          # waiting for BLAST finished
+          while /Your job ID is/ =~ @output and
+              /Your result will be displayed here\<br\>/ =~ @output
+            if /This page will be reloaded automatically in\s*((\d+)\s*min\.)?\s*(\d+)\s*sec\./ =~ @output then
+              reloadtime = $2.to_i * 60 + $3.to_i
+              reloadtime = 300 if reloadtime > 300
+              reloadtime = 1 if reloadtime < 1
+            else
+              reloadtime = 5
+            end
+            if $VERBOSE then
+              $stderr.puts "waiting #{reloadtime} sec to reload #{newuri.to_s}"
+            end
+            sleep(reloadtime)
+            result = http.get(newpath)
+            @output = result.body
+          end
+        end
+
+        # workaround 2005.08.12
+        if /\<A +HREF=\"(http\:\/\/blast\.genome\.jp(\/tmp\/[^\"]+))\"\>Show all result\<\/A\>/i =~ @output.to_s then
+          result = http.get($2)
+          @output = result.body
+          txt = @output.to_s.split(/\<pre\>/)[1]
+          raise 'cannot understand response' unless txt
+          txt.sub!(/\<\/pre\>.*\z/m, '')
+          txt.sub!(/.*^ \-{20,}\s*/m, '')
+          @output = txt.gsub(/\&lt\;/, '<')
+        else
+          raise 'cannot understand response'
+        end
+      end
+
+      # for -m 0 (NCBI BLAST default) output, html tags are removed.
+      if opt_m.to_i == 0 then
+        #@output_bak = @output
+        txt = @output.gsub(/^\s*\<img +src\=\"\/Fig\/arrow\_top\.gif\"\>.+$\r?\n/, '')
+        txt.gsub!(/^.+\<\/form\>$/, '')
+        txt.gsub!(/^\<form *method\=\"POST\" name\=\"clust\_check\"\>.+$\r?\n/, '')
+        txt.gsub!(/\<[^\>\<]+\>/m, '')
+        @output = txt
+      end
+
+      return @output
+    end
+
+  end # class GenomeNet
+
+  # alias for lazy load
+  Genomenet = GenomeNet
+
+end # module Bio::Blast::Remote
+

data/lib/bio/appl/blast/ncbioptions.rb

@@ -0,0 +1,220 @@
+#
+# = bio/appl/blast/ncbioptions.rb - NCBI Tools-style options parser
+#
+# Copyright::  Copyright (C) 2008 Naohisa Goto <ng@bioruby.org>
+# License::    The Ruby License
+#
+# $Id:$
+#
+# == Description
+#
+# Bio::Blast::NCBIOptions is a class to parse and store NCBI Tools-style
+# command-line options.
+# It is internally used in Bio::Blast and some other classes.
+#
+
+require 'bio/appl/blast'
+require 'shellwords'
+
+class Bio::Blast
+
+  # A class to parse and store NCBI-tools style command-line options.
+  # It is internally used in Bio::Blast and some other classes.
+  #
+  class NCBIOptions
+
+    # creates a new object from an array
+    def initialize(options = [])
+      #@option_pairs = []
+      @option_pairs = _parse_options(options)
+    end
+
+    # (protected) option pairs. internal use only.
+    attr_reader :option_pairs
+    protected :option_pairs
+
+    # (private) parse options from given array
+    def _parse_options(options)
+      i = 0
+      pairs = []
+      while i < options.size
+        opt = options[i].to_s
+        if m = /\A(\-.)/.match(opt) then
+          key = m[1]
+          if m.post_match.empty? then
+            i += 1
+            val = options.fetch(i) rescue ''
+          else
+            val = m.post_match
+          end
+          pairs.push([ key, val ])
+        elsif '-' == opt then
+          pairs.push [ opt ]
+        else
+          #warn "Arguments must start with \'-\'" if $VERBOSE
+          pairs.push [ opt ]
+        end
+        i += 1
+      end
+      pairs
+    end
+    private :_parse_options
+
+    # Normalize options.
+    # For two or more same options (e.g. '-p blastn -p blastp'),
+    # only the last option is used. (e.g. '-p blastp' for above example).
+    # 
+    # Note that completely illegal options are left untouched.
+    #
+    # ---
+    # *Returns*:: self
+    def normalize!
+      hash = {}
+      newpairs = []
+      @option_pairs.reverse_each do |pair|
+        if pair.size == 2 then
+          key = pair[0]
+          unless hash[key] then
+            newpairs.push pair
+            hash[key] = pair
+          end
+        else
+          newpairs.push pair
+        end
+      end
+      newpairs.reverse!
+      @option_pairs = newpairs
+      self
+    end
+
+    # current options as an array of strings
+    def options
+      @option_pairs.flatten
+    end
+
+    # parses a string and returns a new object
+    def self.parse(str)
+      options = Shellwords.shellwords(str)
+      self.new(options)
+    end
+
+    # (private) key string to regexp
+    def _key_to_regexp(key)
+      key = key.sub(/\A\-/, '')
+      Regexp.new('\A\-' + Regexp.escape(key) + '\z')
+    end
+    private :_key_to_regexp
+
+    # Return the option.
+    # ---
+    # *Arguments*:
+    # * _key_: option name as a string, e.g. 'm', 'p', or '-m', '-p'.
+    # *Returns*:: String or nil
+    def get(key)
+      re = _key_to_regexp(key)
+
+      # Note: the last option is used when two or more same option exist.
+      value = nil
+      @option_pairs.reverse_each do |pair|
+        if re =~ pair[0] then
+          value = pair[1]
+          break
+        end
+      end
+      return value
+    end
+
+    # Delete the given option.
+    # ---
+    # *Arguments*:
+    # * _key_: option name as a string, e.g. 'm', 'p', or '-m', '-p'.
+    # *Returns*:: String or nil
+    def delete(key)
+      re = _key_to_regexp(key)
+
+      # Note: the last option is used for return value
+      # when two or more same option exist.
+      oldvalue = nil
+      @option_pairs = @option_pairs.delete_if do |pair|
+        if re =~ pair[0] then
+          oldvalue = pair[1]
+          true
+        else
+          false
+        end
+      end
+      return oldvalue
+    end
+
+    # Sets the option to given value.
+    #
+    # For example, if you want to set '-p blastall' option,
+    #   obj.set('p', 'blastall')
+    # or
+    #   obj.set('-p', 'blastall')
+    # (above two are equivalent).
+    #
+    # ---
+    # *Arguments*:
+    # * _key_: option name as a string, e.g. 'm', 'p'.
+    # * _value_: value as a string, e.g. '7', 'blastp'.
+    # *Returns*:: previous value; String or nil
+    def set(key, value)
+      re = _key_to_regexp(key)
+      oldvalue = nil
+      flag = false
+      # Note: only the last options is modified for multiple same options.
+      @option_pairs.reverse_each do |pair|
+        if re =~ pair[0] then
+          oldvalue = pair[1]
+          pair[1] = value
+          flag = true
+          break
+        end
+      end
+      unless flag then
+        key = "-#{key}" unless key[0, 1] == '-'
+        @option_pairs.push([ key, value ])
+      end
+      oldvalue
+    end
+
+    # Adds options from given array.
+    # Note that existing options will also be normalized.
+    # ---
+    # *Arguments*:
+    # * _options_: options as an Array of String objects.
+    # *Returns*:: self
+    def add_options(options)
+      @option_pairs.concat _parse_options(options)
+      self.normalize!
+      self
+    end
+
+    # If self == other, returns true. Otherwise, returns false.
+    def ==(other)
+      return true if super(other)
+      begin
+        oopts = other.options
+      rescue
+        return false
+      end
+      return self.options == oopts 
+    end
+
+    # Returns an array for command-line options.
+    # prior_options are preferred to be used.
+    def make_command_line_options(prior_options = [])
+      newopts = self.class.new(self.options)
+      #newopts.normalize!
+      prior_pairs = _parse_options(prior_options)
+      prior_pairs.each do |pair|
+        newopts.delete(pair[0])
+      end
+      newopts.option_pairs[0, 0] = prior_pairs
+      newopts.options
+    end
+
+  end #class NCBIOptions
+
+end #class Bio::Blast