bio-polyploid-tools 0.1.0

data/lib/bio/PolyploidTools/SNPSequence.rb

@@ -0,0 +1,56 @@
+
+require_relative "SNP"
+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 = reg_str.split(",")
+      elsif arr.size == 2
+       snp.gene, snp.sequence_original = arr
+     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.exon_list = Hash.new()
+      snp
+    end
+    
+    def parse_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/SAMToolsExtensions.rb

@@ -0,0 +1,284 @@
+require 'rubygems'
+require 'pathname'
+#require_relative 'db/fasta.rb'
+require 'bio'
+
+require_relative 'db/fastadb.rb'
+
+#require "set"
+#require 'systemu'
+#require 'json'
+
+=begin
+
+Extends the methods to be able to calculate the BFR and a consensus from the pileup
+
+=end
+
+class Bio::DB::Pileup
+
+  #attr_accessor :minumum_ratio_for_iup_consensus
+  #@minumum_ratio_for_iup_consensus = 0.20
+
+  #Returns a hash with the count of bases
+
+  def bases
+    return @bases if @bases
+    @bases = self.non_refs
+    #puts self.ref_count
+    @bases[self.ref_base.upcase.to_sym] = self.ref_count 
+    @bases
+  end
+
+  def base_coverage
+    total = 0
+    @bases.each do |k,v|
+      total += v  
+    end
+    total
+  end
+
+  def base_ratios
+    return @base_ratios if @base_ratios
+    bases = self.bases
+    @base_ratios = Hash.new
+    bases.each do |k,v| 
+      @base_ratios[k] = v.to_f/self.base_coverage.to_f 
+    end
+    @base_ratios
+  end
+
+  # returns the consensus (most frequent) base from the pileup, if there are equally represented bases returns a string of all equally represented bases in alphabetical order   
+  def consensus_iuap(minumum_ratio_for_iup_consensus)
+    minumum_ratio_for_iup_consensus
+    if @consensus_iuap.nil?
+      @consensus_iuap = self.ref_base.downcase
+      bases = self.bases
+      tmp = String.new
+      bases.each do |k,v|
+        tmp << k[0].to_s if v/self.coverage > minumum_ratio_for_iup_consensus
+      end
+      if tmp.length > 0
+        @consensus_iuap = Bio::NucleicAcid.to_IUAPC(tmp)
+      end
+    end 
+    @consensus_iuap
+  end
+end
+
+
+
+class Bio::NucleicAcid
+
+
+
+  def self.to_IUAPC(bases)
+    #puts "TADA"    
+    base = IUPAC_CODES[bases.to_s.downcase.chars.sort.uniq.join]
+    if base == nil
+      p "Invalid base! #{base}"
+      base = 'n' #This is a patch... as one of the scripts failed here. 
+    end
+    base.upcase
+  end
+
+  def self.is_valid(code, base)
+    IUPAC_CODES[code.downcase].chars.include? base.downcase
+  end
+
+end
+
+
+#class Bio::DB::Sam::SAMException < RuntimeError
+
+#end
+
+class Bio::DB::Sam
+
+
+  attr_accessor :minumum_ratio_for_iup_consensus
+  attr_reader :cached_regions
+  #attr_accessor :pileup_cache
+  @minumum_ratio_for_iup_consensus = 0.20
+
+
+  #Same as mpilup, but it caches the pileup, so if you want several operations on the same set of regions
+  #the pile for different operations, it won't execute the mpilup command several times
+  #Whenever you finish using a region, call mpileup_clear_cache to free the cache
+  #The argument Region is required, as it will be the key for the underlying hash. 
+  #We asume that the options are constant. If they are not, the cache mechanism may not be consistent. 
+  #
+  #TODO: It may be good to load partially the pileup
+  def mpileup_cached (opts={})      
+    raise SAMException.new(), "A region must be provided" unless opts[:r] or opts[:region]
+    @pileup_cache = Hash.new unless @pileup_cache
+    @cached_regions = Hash.new unless @cached_regions
+
+    region = opts[:r] ? opts[:r] : opts[:region]
+    opts[:r] = "#{region.to_s}"
+    opts[:region] = "#{region.to_s}"
+    opts[:A] = true
+    #reg = region.class == Bio::DB::Fasta::Region ? region : Bio::DB::Fasta::Region.parse_region(region.to_s)
+
+    unless @cached_regions[region.to_s]
+      @cached_regions[region.to_s] =  Bio::DB::Fasta::Region.parse_region(region.to_s)
+      tmp = Array.new
+      @cached_regions[region.to_s].pileup =  tmp
+      #puts "Loading #{region.to_s}"
+      mpileup(opts) do | pile | 
+        #   puts pile
+        tmp << pile 
+        yield pile
+      end
+    else   
+      #   puts "Loaded, reruning #{region.to_s}"
+      @cached_regions.pileup[region.to_s] .each do | pile |
+        yield pile
+      end
+    end
+  end
+
+  #Clears the pileup cache. If a region is passed as argument, just the specified region is removed
+  #If no region is passed, the hash is emptied
+  def mpileup_clear_cache (region)
+    return unless @cached_regions
+    if region
+      @cached_regions[region.to_s] = nil
+    else
+      @cached_regions.clear
+    end
+  end
+
+  #Gets the coverage of a region from a pileup. 
+  def average_coverage_from_pileup(opts={})
+    opts[:region] =   opts[:region].to_s if opts[:region] .class == Bio::DB::Fasta::Region 
+    region = opts[:region]
+    calculate_stats_from_pile(opts) if @cached_regions == nil or @cached_regions[region] == nil
+    @cached_regions[region].average_coverage
+  end
+
+  #
+  def coverages_from_pileup(opts={})
+    opts[:region] =   opts[:region].to_s if opts[:region] .class == Bio::DB::Fasta::Region 
+    region = opts[:region]
+    calculate_stats_from_pile(opts) if @cached_regions == nil or @cached_regions[region] == nil
+    @cached_regions[region].coverages
+  end
+
+  def consensus_with_ambiguities(opts={})
+    opts[:region] =   opts[:region].to_s if opts[:region] .class == Bio::DB::Fasta::Region 
+    region = opts[:region]
+    #   p "consensus with ambiguities for: " << opts[:region] 
+    calculate_stats_from_pile(opts) if @cached_regions == nil or @cached_regions[region] == nil
+    @cached_regions[region].consensus
+  end
+
+  def calculate_stats_from_pile(opts={})
+    min_cov = opts[:min_cov] ? opts[:min_cov] : 20  
+
+
+    opts[:region] = Bio::DB::Fasta::Region.parse_region( opts[:region] .to_s)  unless opts[:region].class == Bio::DB::Fasta::Region
+    region = opts[:region]
+    
+    mark_case = true if opts[:case]
+   # puts "Marcase: #{mark_case}"
+    reference = self.fetch_reference(region.entry, region.start, region.end).downcase
+    #  p "calculationg from pile..." << region.to_s
+    base_ratios = Array.new(region.size, BASE_COUNT_ZERO) 
+    bases = Array.new(region.size, BASE_COUNT_ZERO) 
+    coverages = Array.new(region.size, 0)
+    total_cov = 0
+
+    self.mpileup_cached(:region=>"#{region.to_s}") do | pile |
+      #puts pile
+      #puts pile.coverage
+      bef=reference[pile.pos - region.start  - 1 ] 
+      if pile.coverage > min_cov
+        
+      
+        base_ratios[pile.pos - region.start ] = pile.base_ratios
+        reference[pile.pos - region.start  - 1 ] = pile.consensus_iuap(0.20).upcase
+        coverages[pile.pos - region.start   ]  = pile.coverage.to_i
+        bases[pile.pos - region.start   ]  = pile.bases
+        
+       
+      end
+      #puts "#{pile.pos}\t#{bef}\t#{reference[pile.pos - region.start  - 1 ]} "
+      total_cov += pile.coverage
+    end
+
+    #puts ">Ref\n#{reference}"
+    #puts ">Original\n#{r}"
+    region = @cached_regions[region.to_s]
+    region.coverages = coverages
+    region.base_ratios = base_ratios
+    region.consensus = Bio::Sequence.new(reference)
+    region.consensus.na
+    if region.orientation == :reverse
+      region.consensus.reverse_complement!()
+    end
+    region.average_coverage = total_cov.to_f/region.size.to_f
+    region.bases = bases
+    region
+  end
+
+
+
+  #BASE_COUNT_ZERO =  {:A => 0, :C => 0, :G => 0,  :T => 0}
+
+  #Gets an array with the proportions of the bases in the region. If there is no coverage, a
+  def base_ratios_in_region(opts={})
+    opts[:region] =   opts[:region].to_s if opts[:region] .class == Bio::DB::Fasta::Region 
+    region = opts[:region]
+    calculate_stats_from_pile(opts) if @cached_regions == nil or @cached_regions[region] == nil
+    @cached_regions[region].base_ratios 
+  end
+
+  #Gets an array with the bsaes count in the region. If there is no coverage, a
+  def bases_in_region(opts={})
+    opts[:region] =   opts[:region].to_s if opts[:region] .class == Bio::DB::Fasta::Region 
+    region = opts[:region]
+    calculate_stats_from_pile(opts) if @cached_regions == nil or @cached_regions[region] == nil
+    @cached_regions[region].bases 
+  end
+
+
+
+  def extract_reads(opts={})
+    opts[:region] = Bio::DB::Fasta::Region.parse_region( opts[:region] .to_s)  unless opts[:region].class == Bio::DB::Fasta::Region
+    fastq_filename = opts[:fastq]
+    fastq_file = opts[:fastq_file]
+
+    out = $stdout
+
+    print_fastq = Proc.new do |alignment|
+      out.puts "@#{alignment.qname}"
+      out.puts "#{alignment.seq}"
+      out.puts "+#{alignment.qname}"
+      out.puts "#{alignment.qual}"
+    end
+
+    fetch_with_function(chromosome, qstart, qstart+len,  print_fastq)
+
+
+  end
+
+end
+
+class Bio::DB::Fasta::Region
+  attr_accessor :pileup, :average_coverage, :snps, :reference, :base_ratios, :consensus, :coverages, :bases
+
+  #TODO: Debug, as it hasnt been tested in the actual code. 
+  def base_ratios_for_base(base)
+    @all_ratios = Hash.new unless @all_ratios
+    unless @all_ratios[base]
+      ratios = Array.new
+      for i in (0..region.size-1)
+        ratios << @base_ratios[i][base]
+      end
+      @all_ratios[base] = ratios
+    end
+    @all_ratios[base]
+  end
+
+end

data/lib/bio/db/exonerate.rb

@@ -0,0 +1,272 @@
+# 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 identity
+      @pi
+    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 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)
+      #puts "Flanking region for #{position} in exon between ( #{query_id}:#{query_start}-#{query_end}), the target in #{target_snp_pos} ( #{target_id}:#{target_start}-#{target_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
+        #puts "Returning nil"
+        @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