bio-polymarker 1.3.2

data/lib/bio/BIOExtensions.rb

@@ -0,0 +1,153 @@
+
+
+class Bio::Blat
+  def self.align(database , query , output)
+    cmdline = "blat #{database} #{query}  #{output}"
+    puts $stderr.puts cmdline
+    status, stdout, stderr = systemu cmdline
+    if status.exitstatus == 0
+      alns = Array.new unless block_given?
+      blat_aln = Bio::Blat::Report.new(Bio::FlatFile.open(output).to_io)
+      #p blat_aln
+      blat_aln.each_hit() do |hit|
+        if block_given?
+          yield hit
+        else
+          alns << hit
+        end
+      end
+      return alns unless block_given?
+    else
+      raise Exception.new(), "Error running exonerate. Command line was '#{cmdline}'\nBlat STDERR was:\n#{stderr}"
+    end
+  end
+end
+
+class Bio::Blat::Report::Hit
+  
+  #Function to parse stuff like: IWGSC_CSS_1AL_scaff_110
+  def wheat_chr_arm
+    @wheat_chr_arm if @wheat_chr_arm
+    @wheat_chr_arm = target_id.split('_')[2]
+  end
+  
+  def wheat_chr
+    wheat_chr_arm[0,2]
+  end
+  
+  def wheat_chr_group 
+    raise Exception.new(), "No wheat group for #{target_id} #{self.inspect}"  unless wheat_chr
+    wheat_chr_arm[0]
+  end
+  
+  def wheat_genome
+    wheat_chr_arm[1]
+  end
+  
+  def wheat_arm
+    wheat_chr_arm[2]
+  end
+  
+  def percentage_covered
+    ( match + mismatch ) * 100.0 / query_len.to_f
+  end
+  
+end
+
+
+class Hash
+  def join(keyvaldelim=$,, entrydelim=$,)
+    map {|e| e.join(keyvaldelim) }.join(entrydelim)
+  end
+end
+
+
+class Bio::NucleicAcid
+
+  IUPAC_CODES ||= {
+
+    'y' => 'ct',
+    'r' => 'ag',
+    'w' => 'at',
+    's' => 'cg',
+    'k' => 'gt',
+    'm' => 'ac',
+
+    'b' => 'cgt',
+    'd' => 'agt',
+    'h' => 'act',
+    'v' => 'acg',
+
+    'n' => 'acgt',
+
+    'a' => 'a',
+    't' => 't',
+    'g' => 'g',
+    'c' => 'c',
+    'u' => 'u',
+
+    'ct' => 'y',
+    'ag' => 'r',
+    'at' => 'w',
+    'cg' => 's',
+    'gt' => 'k',
+    'ac' => 'm',
+
+    'cgt' => 'b',
+    'agt' => 'd',
+    'act' => 'h',
+    'acg' => 'v',
+
+    'acgt' => 'n'
+  }
+
+  
+  def self.is_unambiguous(base)
+    "acgtACGT".match(base)
+  end
+
+  def self.to_IUAPC(bases)    
+    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
+
+#Monkey patching to Bio::Sequence to find snps between sequences. It assumes the
+#sequences are already aligned and doesn't check if a base on the first sequence is
+#valid on the second. 
+class Bio::Sequence
+  def self.snps_between(seq1, seq2)
+    snps=0
+    for i in (0..seq1.size-1)
+      snps += 1 if seq1[i] != seq2[i] 
+    end
+    snps
+  end
+end
+
+class  String
+  #Monkey patching to count how many ambiguity codes are present in the string, for Nucleic Acids
+  def count_ambiguities
+    snps=0
+
+    for i in (0..self.size-1)
+
+      snps += 1 if !Bio::NucleicAcid.is_unambiguous(self[i])
+    end
+    snps
+  end
+  
+  #Counts how many bases are uppercase
+  def upper_case_count
+    match(/[^A-Z]*/).to_s.size
+  end
+end

data/lib/bio/PolyploidTools/ChromosomeArm.rb

@@ -0,0 +1,63 @@
+module Bio::PolyploidTools
+class ChromosomeArm
+
+  @@arm_selection_functions = Hash.new;
+
+  #example format: chr2A
+  @@arm_selection_functions[:nrgene] = lambda do | contig_name |
+    ret = contig_name[3,2]
+    return ret
+  end
+
+  @@arm_selection_functions[:first_two] = lambda do | contig_name |
+    contig_name.gsub!(/chr/,"")
+    ret = contig_name[0,2]       
+    return ret
+  end
+
+  #Function to parse stuff like: "IWGSC_CSS_1AL_scaff_110"
+  #Or the first two characters in the contig name, to deal with 
+  #pseudomolecules that start with headers like: "1A"
+  #And with the cases when 3B is named with the prefix: v443
+  @@arm_selection_functions[:embl] = lambda do | contig_name|
+
+    arr = contig_name.split('_')
+    ret = "U"
+    ret = arr[2][0,2] if arr.size >= 3
+    ret = "3B" if arr.size == 2 and arr[0] == "v443"
+    ret = arr[0][0,2] if arr.size == 1   
+    return ret
+  end
+
+  @@arm_selection_functions[:morex] = lambda do | contig_name |
+    ret = contig_name.split(':')[0].split("_")[1];       
+    return ret
+  end
+
+  @@arm_selection_functions[:scaffold] = lambda do | contig_name |
+    ret = contig_name;       
+    return ret
+  end
+
+  def self.getArmSelection(name)
+    arr = name.split(",")
+    if arr.size == 2
+       @@arm_selection_functions[name.to_sym] = lambda do |contig_name|
+          separator, field = arr
+          field = field.to_i
+          ret = contig_name.split(separator)[field]
+          return ret
+        end
+    end
+    @@arm_selection_functions[name.to_sym]
+  end
+
+  def self.getValidFunctions
+    tmp = @@arm_selection_functions.keys.map { |e| e.to_s }
+    tmp.unshift "<sep>,<index>"
+    tmp
+  end
+
+
+end
+end

data/lib/bio/PolyploidTools/ExonContainer.rb

@@ -0,0 +1,245 @@
+#puts "Loading ExonCointainer..."
+module Bio::PolyploidTools
+  class ExonContainer
+    attr_reader :parental_1_sam,  :parental_2_sam  
+    attr_reader :parental_1_name, :parental_2_name, :gene_models_db
+    attr_reader :chromosomes, :snp_map
+    attr_reader :parents
+    attr_accessor :flanking_size , :primer_3_min_seq_length, :max_hits
+
+    BASES = [:A, :C, :G, :T]
+    #Sets the reference file for the gene models
+
+    def initialize
+      @parents=Hash.new
+      @snp_map = Hash.new 
+      @primer_3_min_seq_length = 50
+      @max_hits = 10
+    end
+
+    def gene_models(path)
+      @gene_models_db = Bio::DB::Fasta::FastaFile.new(fasta: path)
+      @gene_models_db.index
+      @gene_models_path = path
+    end
+
+    #Returns the sequence for a region in the gene models (exon)
+    def gene_model_sequence(region)
+      #puts "Region: "
+      #puts region.inspect
+      target_reg = @gene_models_db.index.region_for_entry(region.entry)
+      #puts target_reg.inspect
+      region.end = target_reg.length if region.end > target_reg.length
+      #entries[region.entry]
+
+      seq=@gene_models_db.fetch_sequence(region)
+      #puts "sequence: "
+      #This is a patch that we need to fix in biosamtools: 
+      #puts seq
+      index = seq.index('>')
+      if(index )
+        index -= 1
+        #puts "Index: #{index}"
+        seq = seq.slice(0..index) 
+      end
+      #puts seq
+      seq
+    end
+
+    #Sets the reference file for the gene models
+    def chromosomes(path)
+      @chromosomes_db = Bio::DB::Fasta::FastaFile.new(fasta: path)
+      @chromosomes_path = path
+    end
+
+    #Retunrs the sequence for a region in the gene models (exon)
+    def chromosome_sequence(region)
+      left_pad = 0
+      #TODO: Padd if it goes to the right
+      if(region.start < 1)
+        left_pad = region.start * -1
+        left_pad += 1
+        region.start = 1
+      end
+      str = "-" * left_pad << @chromosomes_db.fetch_sequence(region)
+      #str << "n" * (region.size - str.size + 1) if region.size > str.size
+      str
+    end 
+
+   
+    def add_chromosome_arm(opts)
+      @chromosomes = Hash.new unless @chromosomes
+      name = opts[:name]
+      path = opts[:reference_path]
+      path = opts[:alig_path]
+      chromosomes[name] = Bio::DB::Fasta::FastaFile.new(fasta: path)
+    end
+    
+    def add_snp(snp)
+      snp.max_hits = self.max_hits
+      @snp_map[snp.gene] = Array.new unless   @snp_map[snp.gene] 
+      @snp_map[snp.gene] << snp
+
+    end
+
+    def add_snp_file(filename, chromosome, snp_in, original_name)
+
+      File.open(filename) do | f |
+        f.each_line do | line |
+          snp = SNP.parse(line)
+          snp.flanking_size = flanking_size
+          if snp.position > 0
+            snp.container = self
+            snp.chromosome = chromosome
+            snp.snp_in = snp_in
+            snp.original_name = original_name
+            @snp_map[snp.gene] = Array.new unless   @snp_map[snp.gene] 
+            @snp_map[snp.gene] << snp   
+          end
+
+        end
+      end
+    end
+
+   
+
+    def fasta_string_for_snp(snp)
+      gene_region = snp.covered_region
+      local_pos_in_gene = snp.local_position
+      ret_str = ""
+      @parents.each  do |name, bam|
+        ret_str << ">#{gene_region.id}_SNP-#{snp.position}_#{name} Overlapping_exons:#{gene_region.to_s} localSNPpo:#{local_pos_in_gene+1}\n" 
+        to_print =  bam.consensus_with_ambiguities(region: gene_region).to_s
+        to_print[local_pos_in_gene] = to_print[local_pos_in_gene].upcase
+        ret_str << to_print << "\n"
+      end
+
+      snp.exon_list.each do | chromosome,  exon |
+        target_region = exon.target_region
+        exon_start_offset = exon.query_region.start - gene_region.start
+        chr_local_pos=local_pos_in_gene + target_region.start + 1
+        ret_str  << ">#{chromosome}_SNP-#{chr_local_pos} #{exon.to_s} #{target_region.orientation}\n"
+        to_print =  "-" * exon_start_offset 
+        chr_seq  =  chromosome_sequence(exon.target_region).to_s
+        l_pos    =  exon_start_offset + local_pos_in_gene
+        to_print << chr_seq
+        to_print[local_pos_in_gene] = to_print[local_pos_in_gene].upcase
+        ret_str  << to_print
+      end
+      ret_str
+    end
+
+    def print_fasta_snp_exones (file)
+      @missing_exons = Set.new unless @missing_exons
+      @snp_map.each do | gene, snp_array|
+        snp_array.each do |snp|
+          #file.puts snp.primer_fasta_string 
+          #puts "In print_fast_np_exones"
+          #puts snp.inspect
+
+          begin 
+            file.puts snp.aligned_sequences_fasta
+          rescue Exception=>e
+            #puts snp.inspect
+            @missing_exons << snp.to_s
+            $stderr.puts "print_fasta_snp_exones:" + snp.to_s + ":" + e.to_s
+            $stderr.puts "Local position: #{snp.local_position}"
+            $stderr.puts "Local position: #{snp.parental_sequences.to_s}"
+            $stderr.puts e.backtrace
+          end
+        end
+      end
+    end
+
+    def print_primer_3_exons (file, target_chromosome , parental,  max_specific_primers: 20 )
+      added = 0
+      
+      @snp_map.each do | gene, snp_array|
+        snp_array.each do |snp|
+          string = ""
+          begin 
+            primer_3_min_seq_length
+            string = snp.primer_3_string( snp.chromosome, parental,  max_specific_primers: max_specific_primers )
+            #TODO: add tan error to the SNP this snp has more than max_hits. 
+            #Or maybe inside the SNP file. 
+            if string.size > 0
+              file.puts string
+              added += 1
+            end 
+           rescue Exception=>e
+              @missing_exons << snp.to_s
+             # $stderr.puts ""
+
+              $stderr.puts "print_primer_3_exons: #{e.to_s} : snp.to_s"
+              $stderr.puts e.backtrace
+            end
+        end 
+      end
+      return added
+    end
+
+    def add_alignments(opts=Hash.new) 
+      opts = { :min_identity=>90, filter_best:false }.merge!(opts)
+      exonerate_filename = opts[:exonerate_file]
+      arm_selection = opts[:arm_selection]
+      filter_best = opts[:filter_best]
+
+      unless arm_selection
+        arm_selection = lambda do | contig_name |
+          ret = contig_name[0,3]       
+          return ret
+        end
+      end
+
+
+      File.open(exonerate_filename) do |f|
+        f.each_line do | line |
+          record = Bio::DB::Exonerate::Alignment.parse_custom(line)
+          if  record and record.identity >= opts[:min_identity]
+            snp_array = @snp_map[record.query_id]
+            if snp_array != nil
+              snp_array.each do |snp|                            
+                if snp != nil and snp.position.between?( (record.query_start + 1) , record.query_end)
+                  begin
+                    exon = record.exon_on_gene_position(snp.position)
+                    snp.add_exon(exon, arm_selection.call(record.target_id), filter_best:filter_best)
+                  rescue Bio::DB::Exonerate::ExonerateException
+                    $stderr.puts "Failed for the range #{record.query_start}-#{record.query_end} for position #{snp.position}"
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+      remove_alignments_over_max_hits
+    end
+
+    def remove_alignments_over_max_hits
+      @snp_map.each_pair do | gene, snp_array| 
+        snp_array.each do |snp|
+          total_hits = snp.exon_list.map {|e| e[1].size}.reduce(0,:+)
+          snp.hit_count = total_hits
+          if total_hits > max_hits
+            snp.exon_list = {} 
+            snp.repetitive = true
+            snp.errors << "The marker is in a repetitive region (#{total_hits} hits to reference)"
+          end
+        end
+      end
+    end
+
+    def add_parental(opts=Hash.new) 
+      # opts = { :name=>opts[:path]}.merge!(opts)
+      sam = nil
+      name = opts[:name] ? opts[:name] : "Unknown"
+      if opts[:path] 
+        path = opts[:path]
+        name = opts[:name] ? opts[:name] : path.basename(".bam")
+        sam =  Bio::DB::Sam.new({:fasta=>@gene_models_path, :bam=>opts[:path]})
+      end
+      @parents[name] = sam
+    end
+  end
+
+end

data/lib/bio/PolyploidTools/Marker.rb

@@ -0,0 +1,175 @@
+module Bio::PolyploidTools
+  class Marker
+    include Comparable
+    #include Virgola
+    attr_reader :template_sequence, :original, :snp
+    attr_accessor :best_hit
+    attr_accessor :index_90k
+    attr_accessor :snp_id
+    attr_accessor :snp_name
+    attr_accessor :chr
+    attr_accessor :coordinates_chr
+    attr_accessor :map_order
+    attr_accessor :chr_arm
+    attr_accessor :distance_cm
+    attr_accessor :sequence
+    attr_writer  :contig
+
+
+
+    #after_map :parse_sequence_snp
+
+    def to_fasta
+      ">#{self.snp_name}\n#{self.template_sequence}"
+    end
+
+    def contig
+      @contig = best_hit.target_id.chomp if best_hit
+      @contig
+    end
+
+    def to_csv
+      "#{index_90k},#{snp_id},#{snp_name},#{chr},#{coordinates_chr},#{map_order},#{chr_arm},#{distance_cm},#{sequence},#{contig}"
+    end
+    
+    def <=>(anOter)
+     return 0 if anOter.snp_name == @snp_name 
+     return @chr_arm <=> anOter.chr_arm  if anOter.chr_arm != @chr_arm
+     return @snp_name  <=> anOter.snp_name if anOter.coordinates_chr == @coordinates_chr
+     return @coordinates_chr <=> anOter.coordinates_chr    
+    end
+
+    def initialize(line)
+      line.chomp!
+      @template_sequence = nil
+      #INDEX_90K,SNP_ID,SNP_NAME,CHR,COORDINATES_CHR,MAP_ORDER,CHR_ARM,DISTANCE_CM,SEQUENCE
+      @index_90k, @snp_id, @snp_name, @chr, @coordinates_chr, @map_order, @chr_arm, @distance_cm, @sequence, @contig = line.split(',')
+      parse_sequence_snp
+    end
+
+    def self.parse(filename)
+      f = File.open(filename, "r").read
+      f.each_line do |line|
+        m = Marker.new(line)
+        yield m if m.template_sequence
+
+      end
+    end
+
+    protected
+    def parse_sequence_snp
+      pos = 0
+      @chr.upcase!
+      match_data = /(?<pre>\w*)\[(?<org>[ACGT])\/(?<snp>[ACGT])\](?<pos>\w*)/.match(sequence)
+      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)}"
+        return @template_sequence
+      end
+      return nil
+    end
+  end
+
+
+  #The map hast to come sorted. 
+  class ArmMap
+    attr_reader :markers , :global_reference, :reference
+    attr_accessor :chromosome
+    def initialize
+      @markers = Hash.new
+    end
+
+    def align_markers(output)
+      Bio::Blat.align(@reference.fasta_path, @fasta_markers, output) do |hit|
+        marker = markers[hit.query_id]
+        best = marker.best_hit
+        unless marker.best_hit 
+          markers[hit.query_id].best_hit = hit
+        else
+          marker.best_hit = hit if hit.score > marker.best_hit.score
+        end
+      end
+    end
+
+    def print_fasta_contigs_for_markers(contigs_file)
+      
+      contigs = Set.new
+      markers.each do |k, marker|
+
+        if marker.best_hit
+          contigs << marker.best_hit.target_id
+        end
+      end
+      
+      fasta=File.open(contigs_file, "w")
+        contigs.each do |contig_id|
+             reg = @reference.index.region_for_entry(contig_id)
+           fasta.puts ">#{contig_id}\n#{@reference.fetch_sequence(reg.get_full_region)}"
+        end
+      fasta.close
+    end
+
+
+
+
+    def print_fasta_markers(filename)
+      @fasta_markers = filename
+      fasta=File.open(filename, "w")
+
+      markers.each do |k, marker|
+        fasta.puts marker.to_fasta 
+      end
+      fasta.close
+    end
+
+    def global_reference(reference)
+      @global_reference = Bio::DB::Fasta::FastaFile.new({:fasta=>reference})
+      @global_reference.load_fai_entries
+    end
+
+    def reference(reference)
+      @reference = Bio::DB::Fasta::FastaFile.new({:fasta=>reference})
+      @reference.load_fai_entries
+    end
+
+    def print_fasta_contigs_from_reference(filename)
+      if File.exist?(filename) 
+        reference(filename)
+        return
+      end
+
+      #puts "loaded"
+
+      fasta=File.open(filename, "w")
+
+      Bio::FlatFile.auto( @global_reference.fasta_path) do |ff|
+        ff.each do |f|
+          chr_reg = arm_selection_embl(f.entry_id)
+          if chr_reg == chromosome
+            fasta.puts f.entry
+          end
+        end
+      end
+      fasta.close
+      reference(filename)
+    end
+
+
+    def print_map_with_contigs(filename)
+      file = File.open(filename, "w")
+      markers.values.sort { |x,y| x.map_order <=> y.map_order }.each do | marker |
+        file.puts marker.to_csv
+      end 
+      file.close
+    end
+
+    protected
+    def arm_selection_embl(contig_name)
+      ret = contig_name.split('_')[2][0,2]
+      return ret
+    end
+  end
+end