bio-polymarker 1.3.2

data/lib/bio/PolyploidTools/SNPMutant.rb

@@ -0,0 +1,86 @@
+
+require_relative "SNPSequence"
+require 'bio-samtools-wrapper'
+module Bio::PolyploidTools
+  class SNPSequenceException < RuntimeError 
+  end
+
+  class SNPMutant < SNPSequence
+
+    attr_accessor :library, :contig, :chr, :parsed_start, :parsed_flanking, :region_size
+    #Format: 
+    #seqid,library,position,wt_base,mut_base
+    #IWGSC_CSS_1AL_scaff_1455974,Kronos2281,127,C,T
+    def self.parse(reg_str)
+      reg_str.chomp!
+      snp = SNPMutant.new
+
+      arr = reg_str.split(",")
+      
+      throw SNPSequenceException.new "Need five fields to parse, and got #{arr.size} in #{reg_str}" if arr.size < 5
+      
+      snp.contig, snp.library, snp.position, snp.original, snp.snp, parsed_flanking, region_size = reg_str.split(",")
+      snp.position = snp.position.to_i
+      snp.gene = "EMPTY"
+      begin
+        toks = snp.contig.split('_')
+        #1AL_1455974_Kronos2281_127C
+        #snp.chr = contig.split('_')[2][0,2] #This parses the default from the IWGSC. We may want to make this a lambda  
+        #snp.chr = toks[2][0,2]
+        name = toks[2] + "_" + toks[4] + "_" + snp.library + "_" + snp.position.to_s 
+        snp.gene = name
+        snp.chromosome = toks[2][0,2]
+        snp.chr = snp.chromosome
+        
+      rescue Exception => e
+        $stderr.puts "WARN: snp.chr couldnt be set, the sequence id to parse was #{snp.contig}. We expect something like: IWGSC_CSS_1AL_scaff_1455974"
+        snp.gene = "Error"
+        $stderr.puts e
+      end
+      
+      snp.flanking_size=100
+      snp.region_size = region_size.to_i if region_size
+      snp.flanking_size = parsed_flanking.to_i if parsed_flanking
+      snp
+    end
+    
+    def full_sequence=(seq)
+      self.template_sequence = seq
+      self.sequence_original = self.to_polymarker_sequence(self.flanking_size)
+      self.parse_sequence_snp
+    end
+
+    def full_sequence()
+      self.template_sequence
+    end
+
+    def chromosome_group
+      chr[0]
+    end
+    
+    def chromosome_genome
+      chr[1]
+    end
+    
+    def chromosome_genome
+      return chr[3] if chr[3]
+      return nil
+    end
+      
+    def parse_sequence_snp
+      pos = 0
+      match_data = /(?<pre>\w*)\[(?<org>[ACGT])\/(?<snp>[ACGT])\](?<pos>\w*)/.match(sequence_original.strip)
+      if match_data
+        @position = Regexp.last_match(:pre).size + 1
+        @original = Regexp.last_match(:org)
+        @snp = Regexp.last_match(:snp)
+        amb_base = Bio::NucleicAcid.to_IUAPC("#{@original}#{@snp}")
+        @template_sequence = "#{Regexp.last_match(:pre)}#{amb_base}#{Regexp.last_match(:pos)}"
+        
+     end 
+    end
+    
+   
+
+  end
+end

data/lib/bio/PolyploidTools/SNPSequence.rb

@@ -0,0 +1,55 @@
+
+require_relative "SNP"
+require 'bio-samtools-wrapper'
+module Bio::PolyploidTools
+  class SNPSequenceException < RuntimeError 
+  end
+
+  class SNPSequence < SNP
+
+    attr_accessor :sequence_original
+    #Format: 
+    #snp name,chromsome from contig,microarray sequence
+    #BS00068396_51,2AS,CGAAGCGATCCTACTACATTGCGTTCCTTTCCCACTCCCAGGTCCCCCTA[T/C]ATGCAGGATCTTGATTAGTCGTGTGAACAACTGAAATTTGAGCGCCACAA
+    def self.parse(reg_str)
+      reg_str.chomp!
+      snp = SNPSequence.new
+
+      arr = reg_str.split(",")
+      
+      if arr.size == 3
+        snp.gene, snp.chromosome, snp.sequence_original = arr
+      elsif arr.size == 2
+       snp.gene, snp.sequence_original = arr
+       snp.chromosome = ""
+     else
+       throw SNPSequenceException.new "Need two or three fields to parse, and got #{arr.size} in #{reg_str}"
+      end
+      #snp.position = snp.position.to_i
+      #snp.original.upcase!
+      #snp.snp.upcase!  
+      snp.chromosome. strip!
+      snp.parse_sequence_snp
+  
+      snp
+    end
+    
+    def parse_sequence_snp
+      pos = 0
+      match_data = /(?<pre>\w*)\[(?<org>[ACGT])\/(?<snp>[ACGT])\](?<pos>\w*)/.match(sequence_original.strip)
+      if match_data
+        @position = Regexp.last_match(:pre).size + 1
+        @original = Regexp.last_match(:org)
+        @snp = Regexp.last_match(:snp)
+        
+        amb_base = Bio::NucleicAcid.to_IUAPC("#{@original}#{@snp}")
+        
+        @template_sequence = "#{Regexp.last_match(:pre)}#{amb_base}#{Regexp.last_match(:pos)}"
+        
+     end 
+    end
+    
+   
+
+  end
+end

data/lib/bio/db/blast.rb

@@ -0,0 +1,114 @@
+module Bio::DB::Blast
+
+	def self.to_sugar(line)
+		fields = line.split("\t")[0..8]
+		
+		if  fields[3] =="-1"
+			fields[3] = "-"
+			fields[2] = fields[2].to_i - 1
+		else
+			fields[3] = "+"
+			fields[1] = fields[1].to_i - 1
+		end
+		if fields[7] =="-1"
+			fields[7] = "-"
+			fields[6] = fields[6].to_i - 1
+		else
+			fields[7] = "+"
+			fields[5] = fields[5].to_i - 1
+		end
+		fields.join(" ")
+	end
+
+	def self.to_vulgar(line)
+		qseq, sseq = line.split("\t")[12..13]
+
+		len = qseq.length
+		l_status = ""
+		l_len = 0
+		str = Array.new
+		statuses = ""
+		for i in 0..len
+			if qseq[i] == "-"
+				status = "D"
+			elsif sseq[i] == "-"
+				status = "I"
+			else
+				status = "M"
+			end
+			statuses << status
+		end
+		statuses.split('').each do |e| 
+			if l_status != e
+				case l_status
+				when "M"
+					str << ["M", l_len, l_len]
+				when "I"
+					str << ["G", l_len, 0]
+				when "D"
+					str << ["G", 0, l_len]
+				end
+				l_len = 0
+			end
+			l_status = e
+			l_len += 1
+		end
+		l_len -= 1
+		case l_status
+		when "M"
+			str << ["M", l_len, l_len]
+		when "I"
+			str << ["G", l_len, 0]
+		when "D"
+			str << ["G", 0, l_len]
+		end
+
+		str.flatten!.join(" ")
+	end
+
+	def self.to_exo(line)
+		arr = Array.new
+		arr << "RESULT:"
+		arr << to_sugar(line)
+		arr << line.split("\t")[9..11]
+		arr << "."
+		arr << to_vulgar(line)
+		arr.join("\t")
+	end
+
+	def self.align(opts={})
+		target=opts[:target]
+		query=opts[:query]
+		max_target_seqs = 6 #TODO: Actually add this as an argument to PolyMarker. 
+		max_target_seqs = opts[:max_hits] * 2 if opts[:max_hits]
+		cmdline = "blastn -max_target_seqs #{max_target_seqs} -query #{query} -db #{target} -outfmt '6 qseqid qstart qend qframe sseqid sstart send sframe score pident qlen slen qseq sseq'"
+		#puts cmdline
+		status, stdout, stderr = systemu cmdline
+		if status.exitstatus == 0
+			alns = Array.new unless block_given?
+			stdout.each_line do |e_l|
+				#puts e_l
+				line = to_exo(e_l)
+				#puts line
+				arr = line.split("\t")
+				aln = Bio::DB::Exonerate::Alignment.parse_custom(line) 
+				if aln
+					if block_given?
+						yield aln
+					else
+						alns << aln
+					end
+				end
+			end
+			return alns unless block_given?
+		else
+			raise BlasteException.new(), "Error running exonerate. Command line was '#{cmdline}'\n Blast STDERR was:\n#{stderr}"
+		end
+	end	
+
+	class BlasteException < RuntimeError 
+	end	
+
+end
+
+

data/lib/bio/db/exonerate.rb

@@ -0,0 +1,333 @@
+# RYO %S\t%pi\t%ql\t%tl\t%g\t%V\n 
+
+
+module Bio::DB::Exonerate
+
+
+  #TODO: Make a proper object with generic parser
+  def self.align(opts={})
+    opts = {
+      :model => 'affine:local' ,
+      :ryo => "RESULT:\\t%S\\t%pi\\t%ql\\t%tl\\t%g\\t%V\\n" , 
+      :bestn => 20,
+      :percentage => 50
+    }
+    .merge(opts)
+
+    target=opts[:target]
+    query=opts[:query]
+
+    cmdline = "exonerate --verbose 0 --showalignment no --bestn #{opts[:bestn]} --showvulgar no  --model #{opts[:model]}   --ryo '#{opts[:ryo]}' #{query} #{target}"
+    status, stdout, stderr = systemu cmdline
+    #$stderr.puts cmdline
+    if status.exitstatus == 0
+      alns = Array.new unless block_given?
+      stdout.each_line do |line|
+        aln = Alignment.parse_custom(line) 
+        if aln
+          if block_given?
+            yield aln
+          else
+            alns << aln
+          end
+        end
+      end
+      return alns unless block_given?
+    else
+      raise ExonerateException.new(), "Error running exonerate. Command line was '#{cmdline}'\nExonerate STDERR was:\n#{stderr}"
+    end
+  end
+  
+  
+  class ExonerateException < RuntimeError 
+  end
+
+  class Alignment
+    attr_accessor   :query_id, :query_start, :query_end, :query_strand
+    attr_accessor :target_id, :target_start, :target_end, :target_strand, :score
+    attr_accessor :vulgar_block, :pi, :ql, :tl, :g
+    attr_accessor :line
+
+    #This one day may grow to work with complex ryo....
+    def self.parse_custom(line)
+      fields=line.split(/\t/)
+      if fields[0] == "RESULT:"
+        al = Bio::DB::Exonerate::Alignment.new()      
+        al.parse_sugar(fields[1])
+        al.pi = fields[2].to_f 
+        al.ql = fields[3].to_i
+        al.tl = fields[4].to_i
+        al.g  = fields[5]
+        al.parse_vulgar(fields[6])
+        al.line = line
+        return al
+      else
+        return nil
+      end
+    end
+
+    def query
+     unless @query
+       @query = Bio::DB::Fasta::Region.new()
+       @query.entry = query_id 
+       @query.start = query_start + 1
+       @query.end = query_end
+       @query.orientation = query_strand
+       if @query.orientation == :reverse
+        @query.end = query_start 
+        @query.start = query_end + 1
+       end
+       @query
+     end
+     @query
+   end
+
+   def target
+    unless @target
+      @target = Bio::DB::Fasta::Region.new()
+      @target.entry = target_id 
+      @target.start = target_start + 1
+      @target.end = target_end
+      @target.orientation = target_strand
+      if @target.orientation == :reverse
+        @target.end = target_start 
+        @target.start = target_end + 1
+      end
+    end
+    @target
+  end
+
+  def identity
+    @pi
+  end
+  def query_length
+    @ql
+  end
+  def query_coverage
+    total_m = 0
+    vulgar_block.each do |v|  
+      #p v.label
+      if v.label == :M
+        total_m += v.query_length
+      end
+    end
+   #puts "Total m #{total_m}"
+   #puts "ql #{query_length}"
+    return 100.00 * total_m.to_f / query_length.to_f 
+  end
+
+  def parse_sugar(sugar_str)
+    @query_id, @query_start, @query_end, @query_strand, @target_id, @target_start, @target_end, @target_strand, @score = sugar_str.split(/\s+/)
+
+    @query_start  = @query_start.to_i
+    @query_end = @query_end.to_i
+    @target_start = @target_start.to_i
+    @target_end = @target_end.to_i
+    @score = @score.to_f
+
+    if @target_strand == "+"
+      @target_strand = :forward
+    elsif @target_strand == "-"
+      @target_strand = :reverse
+    else
+      raise  ExonerateException.new(), "Ivalid target orientation #{@target_strand} for line:\n#{sugar_str}"
+    end
+
+
+    if @query_strand == "+"
+      @query_strand = :forward
+    elsif @query_strand == "-"
+      @query_strand = :reverse
+    else
+      raise  ExonerateException.new(), "Ivalid query orientation #{@query_strand} for line:\n#{sugar_str}"
+    end
+
+    raise  ExonerateException.new(), "Inconsistent orientation (forward, query)" if @query_strand == :forward and @query_start > @query_end
+    raise  ExonerateException.new(), "Inconsistent orientation (reverse, query)" if @query_strand == :reverse and @query_start < @query_end
+    raise  ExonerateException.new(), "Inconsistent orientation (forward, target)" if @target_strand == :forward and @target_start > @target_end
+    raise  ExonerateException.new(), "Inconsistent orientation (reverse, target)" if @target_strand == :reverse and @target_start < @target_end
+
+
+    self
+  end
+
+
+    #The vulgar has to be parsed AFTER the sugar, otherwise it is impossible to determine the orientations
+    def parse_vulgar(vulgar_str)
+
+      tarcurrent = @target_start
+      query_current = @query_start
+      target_multiply = 1
+      query_multiply = 1
+
+      if @target_strand == :reverse
+        target_multiply = -1
+      end
+
+      if @query_strand == :reverse
+        query_multiply = -1
+      end
+
+      @vulgar_block = Array.new
+      #p "VULGAR #{vulgar_str}"
+      vulgar_str.split(/\s/).each_slice(3) do | block |
+        #p block
+        vulgar = Vulgar.new(block[0].to_sym, block[1].to_i, block[2].to_i, tarcurrent, target_multiply, query_current, query_multiply, self)
+        query_current = vulgar.query_end
+        tarcurrent = vulgar.target_end
+        vulgar_block << vulgar
+      end
+      self
+    end
+
+    #This assumes that the gene is the query and the chromosome is the target
+    def exon_on_gene_position(position)
+      @vulgar_block.each do |vulgar|
+        if position.between?(vulgar.query_start, vulgar.query_end)
+          return vulgar
+        end
+      end
+      nil
+    end
+
+    def query_position_on_target(position, base:0)
+      vulgar = exon_on_gene_position(position)
+      qr = vulgar.query_region
+      tr = vulgar.target_region
+      
+      offset = qr.orientation == :forward ? position - qr.start + 1 : qr.end - position
+
+      #puts vulgar.to_s
+      #puts "SNP position: #{position}"
+      #puts vulgar.query_region
+      #puts vulgar.query_region.orientation
+      #puts "Offset query: #{offset}"
+      #puts vulgar.target_region
+      #puts vulgar.target_region.orientation
+
+      new_pos = tr.orientation == :forward ? offset + tr.start - 1 :  tr.end - offset + 1
+
+      return new_pos
+    end
+
+    def tarpostion_from_query_position(position)
+      ret = nil
+      vulgar_block = exon_on_gene_position(position)
+      ret
+    end
+
+    def print_features
+      out = String.new
+
+      @vulgar_block.each do |  vulgar |
+        out << vulgar.to_s << "\n"
+      end
+      out
+    end
+  end
+
+  class Vulgar
+    attr_reader :label, :query_length, :target_length, :query_start, :query_end, :target_start, :target_end, :record, :snp_in_gap
+    def initialize(label, ql, tl, target_start, target_multiply, query_start, query_multiply, record)
+      @label = label
+      @query_length = ql
+      @target_length = tl
+      @query_start = query_start
+      @query_end = query_start + (query_multiply   * query_length)
+      @target_start = target_start
+      @target_end = target_start + (target_multiply * target_length)
+      @record = record
+      @snp_in_gap = false
+    end    
+
+    def to_s
+      out = String.new
+      out << @label.to_s << "\t" << @query_length.to_s << "\t" << @target_length.to_s << "\t" << @query_start.to_s << "\t" << @query_end.to_s << "\t" << @target_start.to_s << "\t" << @target_end.to_s 
+      out
+    end
+
+    def query_id
+      record.query_id
+    end
+
+    def target_id
+      record.target_id
+    end
+
+    def target_flanking_region_from_position(position, flanking_size)
+      reg = reg = Bio::DB::Fasta::Region.new()
+      reg.entry = target_id
+      target_snp_pos = target_position_from_query(position)
+      return nil if snp_in_gap 
+      reg.orientation = record.target_strand
+      reg.start = target_snp_pos - flanking_size
+      reg.end = target_snp_pos + flanking_size
+      raise  ExonerateException.new "Target Query out of bounds!" unless position.between?(query_start, query_end)
+
+      reg
+    end
+
+    def target_position_from_query(position)
+      raise ExonerateException.new(), "Position: #{position} not in range (#{query_start}-#{query_end}) #{self.to_s} " unless position.between?(query_start, query_end) or position.between?(query_end, query_start) 
+      offset = 0
+      ret = 0
+      if record.query_strand == :forward
+        offset = position - query_start
+      elsif record.query_strand == :reverse
+        offset = query_start - position
+      else
+        raise ExonerateException.new(), "The strand is not forward or reverse (#{record.query_strand}) ! #{self.inspect}"
+      end
+
+      if record.target_strand == :forward
+        ret = target_start + offset
+      elsif record.target_strand == :reverse
+        ret = target_start - offset + 1
+      else
+        raise ExonerateException.new(), "The strand is not forward or reverse! #{self.inspect}"
+      end
+      #THis is in case the position is on a gap. 
+      if @target_length == 0 and label == :G
+        @snp_in_gap = true
+        ret = target_start
+      end
+      raise ExonerateException.new(), "Return position #{ret} outside block (#{target_start}-#{target_end}, #{self.inspect})" unless ret.between?(target_start, target_end) or ret.between?(target_end, target_start)
+      ret
+    end
+
+    def query_region
+      reg = Bio::DB::Fasta::Region.new()
+      reg.entry = query_id
+      reg.orientation = record.query_strand 
+      if record.query_strand == :forward
+        reg.start = @query_start + 1
+        reg.end =  @query_end 
+      elsif record.query_strand == :reverse
+        reg.start = @query_end + 1
+        reg.end =  @query_start 
+      else
+        raise  ExonerateException.new(), "Ivalid query orientation #{@query_strand}"
+      end
+      reg
+    end
+
+    def target_region
+      reg = Bio::DB::Fasta::Region.new()
+
+      reg.entry = target_id
+      reg.orientation = record.target_strand 
+      if record.target_strand == :forward
+        reg.start = @target_start + 1
+        reg.end =  @target_end 
+      elsif record.target_strand == :reverse
+        reg.start = @target_end + 1
+        reg.end =  @target_start 
+      else
+        raise  ExonerateException.new(), "Ivalid target orientation #{@target_strand}"
+      end
+      reg
+    end
+
+  end
+
+end