bio-polyploid-tools 0.1.0

data/lib/bio/BIOExtensions.rb

@@ -0,0 +1,186 @@
+
+module Bio::NucleicAcid::Data
+  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'
+  }
+
+
+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
+
+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
+  def count_ambiguities
+    snps=0
+
+    for i in (0..self.size-1)
+
+      snps += 1 if !Bio::NucleicAcid.is_unambiguous(self[i])
+    end
+    snps
+  end
+  
+  def upper_case_count
+    match(/[^A-Z]*/).to_s.size
+  end
+end
+
+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

data/lib/bio/PolyploidTools/ChromosomeArm.rb

@@ -0,0 +1,52 @@
+module Bio::PolyploidTools
+  
+  class ChromosomeArm
+    attr_accessor :name
+    attr_reader :genes
+    attr_reader :loaded_entries
+    attr_reader :fasta_db
+
+    def initialize(name, path_to_fasta)
+      @name = name
+      @fasta_db = Bio::DB::Fasta::FastaFile.new(path_to_fasta)
+      #$stderr.puts "Loading entries for #{name}"
+      
+      @genes = Hash.new
+    end
+    
+    def fetch_contig(contig_id)
+      
+      @fasta_db.load_fai_entries unless @loaded_entries
+      @loaded_entries = true
+      entry = fasta_db.index.region_for_entry(contig_id)
+     # puts entry
+      @fasta_db.fetch_sequence(entry.get_full_region)
+    end
+    #Loads all the chromosome arms in a folder. 
+    #The current version requires that all the references end with .fa, and start with XXX_*.fa
+    #Where XXX is the chromosome name
+    def self.load_from_folder(path_to_contigs)
+      chromosomeArms = Hash.new
+      
+      Dir.foreach(path_to_contigs) do |filename |
+        
+        if  File.fnmatch("*.fa", filename)
+          
+          parsed = /^(?<arm>\d\w+)/.match(filename)
+         
+          target="#{path_to_contigs}/#{filename}"
+          
+         
+         
+         # fasta_file = Bio::DB::Fasta::FastaFile.new(target)
+          #fasta_file.load_fai_entries
+          arm = ChromosomeArm.new(parsed[:arm], target)
+          chromosomeArms[arm.name] = arm
+        end
+      end
+      return chromosomeArms
+    end
+    
+  end
+
+end

data/lib/bio/PolyploidTools/ExonContainer.rb

@@ -0,0 +1,194 @@
+#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
+
+    BASES = [:A, :C, :G, :T]
+    #Sets the reference file for the gene models
+
+    def initialize
+      @parents=Hash.new
+      @snp_map = Hash.new 
+      @snp_contigs
+    end
+
+    def gene_models(path)
+      @gene_models_db = Bio::DB::Fasta::FastaFile.new(path)
+      @gene_models_path = path
+    end
+
+    #Retunrs the sequence for a region in the gene models (exon)
+    def gene_model_sequence(region)
+      seq=@gene_models_db.fetch_sequence(region)
+
+
+    end
+
+    #Sets the reference file for the gene models
+    def chromosomes(path)
+      @chromosomes_db = Bio::DB::Fasta::FastaFile.new(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 < 0)
+        left_pad = region.start * -1
+        left_pad += 1
+        region.start = 0
+      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(path)
+    end
+    
+    def add_snp(snp)
+      @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 primer_3_input_for_snp(snp)
+      gene_region = snp.covered_region
+      local_pos_in_gene = snp.local_position
+      puts ""
+    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
+      puts ret_str
+      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 
+          begin 
+            file.puts snp.aligned_sequences_fasta
+          rescue Exception=>e
+            @missing_exons << snp.to_s
+#            $stderr.puts e.to_s
+          end
+        end
+      end
+    end
+
+    def print_primer_3_exons (file, target_chromosome , parental )
+      @snp_map.each do | gene, snp_array|
+        snp_array.each do |snp|
+          begin 
+          string = snp.primer_3_string( snp.chromosome, parental )
+          file.puts string if string.size > 0
+           rescue Exception=>e
+             @missing_exons << snp.to_s
+              #$stderr.puts e.to_s
+            end
+        end 
+      end
+    end
+
+    def add_alignments(opts=Hash.new) 
+      opts = { :min_identity=>90 }.merge!(opts)
+      exonerate_filename = opts[:exonerate_file]
+      arm_selection = opts[:arm_selection]
+
+      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))
+                  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
+    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(reference)
+      @global_reference.load_fai_entries
+    end
+
+    def reference(reference)
+      @reference = Bio::DB::Fasta::FastaFile.new(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