bio-polyploid-tools 0.1.0 → 0.2.3

data/lib/bio/SAMToolsExtensions.rb

@@ -1,284 +0,0 @@
-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/fastadb.rb

@@ -1,164 +0,0 @@
-#Module to hold the information about the fasta file
-
-module Bio::DB::Fasta
-  class Index
-    include Enumerable
-    attr_reader :entries
-    
-    def initialize
-      @entries=[]
-      @entries_map = Hash.new
-    end
-    
-    #This doesnt validate if you are adding the same entry twice. I may add
-    #a validation for that. 
-    def << (entry)
-      @entries << entry
-      @entries_map[entry.id] = entry
-    end
-    
-    def each(&block)
-      @entries.entries(&block)
-    end  
-    
-    def length
-       @entries.length
-    end
-    
-    #Returns a new Index just with the specified range, as if it was an Array. 
-    #The return object is of type Index. 
-    def [](args)
-      tmp = @entries[args]
-      new_index = Index.new
-      tmp.each do | entry |
-        @new_index << entry
-      end       
-    end
-    
-    def region_for_entry(entry)
-       @entries_map[entry]
-    end
-  end
-  
-  class Entry
-    attr_reader :id, :length
-    
-    def initialize(id, length)
-      @id=id
-      @length=length.to_i
-    end
-    
-    def get_full_region
-      reg = Region.new
-      reg.entry = id
-      reg.start = 0
-      reg.end = @length
-      reg.orientation = :forward
-      reg
-    end
-    
-    def to_region
-      get_full_region
-    end
-  end
-  
-  #Class to wrap a region of a chromosome
-  class Region
-    attr_accessor :entry, :start, :end, :orientation
-    
-    def to_s
-      string = @entry + ":" + @start.to_s + "-" + @end.to_s 
-      string
-    end
-    
-    def self.parse_region(reg_str)
-        string = reg_str.delete("'")
-        fields_1 = string.split(":")
-        fields_2 = fields_1[1].split("-")
-        raise FastaDBException.new(), "Invalid region. #{string}" if fields_1.length != 2 || fields_2.length != 2
-        
-        reg = Region.new
-        reg.entry = fields_1[0]
-        reg.start = fields_2[0].to_i
-        reg.end = fields_2[1].to_i
-        
-        if reg.end < reg.start 
-          reg.orientation = :reverse
-        else
-          reg.orientation = :forward
-        end
-        reg
-    end
-    
-    def size
-      @end - @start
-    end
-  
-  end
-  
-  class FastaDBException < StandardError; end
-  
-  #Class that holds the fasta file. It is used as a database. It heavily relies ond samtools. 
-  class FastaFile
-    
-    attr_reader :index, :fasta_path
-    
-    def FastaFile.finalize(id)
-      #id.close()
-      #puts "Finalizing #{id}  at #{Time.new}"       
-    end
-    
-    def initialize(fasta_filename)
-      @fasta_path = fasta_filename
-      raise FastaDBException.new(), "No path for the refernce fasta file. " if @fasta_path.nil?
-      @fasta_index = Bio::DB::SAM::Tools.fai_load(@fasta_path)
-      if @fasta_index.null? then
-        $stderr.puts "Generating index for: " + @fasta_path
-        Bio::DB::SAM::Tools.fai_build(@fasta_path)
-        @fasta_index =  Bio::DB::SAM::Tools.fai_load(@fasta_path)
-        raise FastaDBException.new(), "Unable to generate fasta index for: " + @fasta_path if @fasta_index.nil? ||  @fasta_index.null?
-      end
-      ObjectSpace.define_finalizer(self,  self.class.method(:finalize).to_proc)
-    end
-    
-    def load_fai_entries()
-      return  @index.length if @index
-      @index = Index.new
-      fai_file = @fasta_path + ".fai"
-      File.open(fai_file).each do | line |
-        fields = line.split("\t")
-        @index << Entry.new(fields[0], fields[1])
-        
-      end     
-      @index.length
-    end
-    
-    def close()
-       Bio::DB::SAM::Tools.fai_destroy(@fasta_index) unless @fasta_index.nil? || @fasta_index.null?
-       @fasta_index = nil
-    end
-    
-    #The region needs to have a method to_region or a method to_s that ha the format "chromosome:start-end" as in samtools
-    def fetch_sequence(region)
-      
-        raise FastaDBException.new(), "No fasta index for " if @fasta_index.nil? || @fasta_index.null? 
-        query = region.to_s
-        query = region.to_region.to_s if region.respond_to?(:to_region) 
-        
-        len = FFI::MemoryPointer.new :int
-        str = Bio::DB::SAM::Tools.fai_fetch(@fasta_index, query, len)
-        raise FastaDBException.new(), "Unable to get sequence for reference: " + query if str.nil?
-        reference = Bio::Sequence.auto(str)
-        
-        # 
-        
-        if region.orientation == :reverse
-          #puts "reversing! #{reference.to_s}"
-          reference.reverse_complement!()
-        end
-        reference
-    end
-    
-     
-  end
-end