germ 0.1 → 0.3

data/lib/mutation.rb

@@ -0,0 +1,41 @@
+require 'genomic_locus'
+require 'fasta'
+class Mutation
+  include GenomicLocus
+  # This is a generic description of a mutation.
+  VALID_ALLELE = /^[ATGCNatgcn]+$/
+
+  attr_reader :seqname, :pos, :ref, :alt, :ref_count, :alt_count
+  alias_method :start, :pos
+  def initialize seqname, pos, ref, alt, ref_count=nil, alt_count=nil
+    @seqname, @pos, @ref, @alt, @ref_count, @alt_count = seqname, pos, ref, alt, ref_count, alt_count
+  end
+
+  def stop
+    start + ref.size - 1
+  end
+
+  def to_s
+    range.to_s + ":#{ref}-#{alt}"
+  end
+
+  def is_valid?
+    ref =~ VALID_ALLELE && alt =~ VALID_ALLELE
+  end
+
+  def ref_at loc
+    return nil unless contains? loc
+    ref[pos - loc.pos]
+  end
+
+  def var_freq
+    if ref_count && alt_count
+      ref_count / alt_count
+    end
+  end
+
+  def alt_at loc
+    return nil unless contains? loc
+    alt[pos - loc.pos]
+  end
+end

data/lib/mutation_set.rb

@@ -1,69 +1,14 @@
-require 'oncotator'
 require 'yaml'
 require 'intervals'
+require 'hash_table'
+require 'mutation'
 
-module MutationSet
-  class Line
-    include IntervalList::Interval
-    attr_reader :sample
-    attr_accessor :invalid
-
-    def self.alias_key sym1, sym2
-      define_method sym1 do
-        send sym2
-      end
-      define_method "#{sym1}=" do |v|
-        send "#{sym2}=", v
-      end
-    end
-
-    def copy
-      self.class.new @mutation.clone, sample
-    end
-
-    def invalid?
-      invalid
-    end
-
-    def invalidate!
-      @invalid = true
-    end
-
-
-    def initialize(fields, sample)
-      if fields.is_a? Hash
-        @mutation = fields
-      else
-        @mutation = Hash[sample.clean_headers.zip(fields)]
-      end
-      @sample = sample
-    end
-
-    def key
-      "#{chrom}:#{start}:#{stop}"
-    end
-
-    def long_chrom
-      @long_chrom ||= "chr#{short_chrom}"
-    end
-
-    def short_chrom
-      @short_chrom ||= chrom.sub(/^chr/,'')
-    end
-
-    def to_s
-      sample.clean_headers.map{ |h| @mutation[h] }.join("\t")
-    end
-
-    def to_hash
-      @mutation
-      #Hash[@mutation.map do |k,v| [ k, v ? v.clone : v ]; end]
-    end
-
+class Mutation
+  module Filtering
     def criteria_failed? obj, name
-      return nil if !sample.mutation_config
+      return nil if !@table.mutation_config
       name = [ name ] if !name.is_a? Array
-      crit = name.reduce(sample.mutation_config) do |h,n|
+      crit = name.reduce(@table.mutation_config) do |h,n|
         h.is_a?(Hash) ? h[n] : nil
       end
       return nil if !crit
@@ -112,10 +57,10 @@ module MutationSet
         end
         return v
       when /^whitelisted/
-        whitelist = sample.whitelist value
+        whitelist = @table.whitelist value
         return whitelist.intersect(self)
       when /^blacklisted/
-        blacklist = sample.blacklist value
+        blacklist = @table.blacklist value
         return !blacklist.intersect(self)
       else
         # send it
@@ -128,129 +73,45 @@ module MutationSet
       end
       true
     end
+  end
+end
 
-    def onco
-      raise ArgumentError, @onco_error unless valid_onco_input?
-      @onco ||= Oncotator.new :key => self.to_ot
-    end
-
-    def discard_onco
-      @onco = nil
-    end
-
-    def skip_oncotator? criteria=nil
-      return true if !onco || onco.empty? || criteria_failed?(onco, criteria || :oncotator)
-    end
-
-    def inspect
-      "#<#{self.class.name}:#{object_id} @mutation=#{@mutation}>"
-    end
-
-    def in_cosmic
-      onco.Cosmic_overlapping_mutations ? "YES" : "NO"
-    end
-
-    def to_ot
-      [ short_chrom, start, stop, ref_allele, alt_allele ].join("_")
-    end
-
-    def method_missing(meth,*args,&block)
-      if meth.to_s =~ /(.*)=/ 
-        @mutation[$1.to_sym] = args.first
-      else
-        @mutation.has_key?(meth.to_sym) ? @mutation[meth.to_sym] : super
-      end
+class Mutation
+  class Record < HashTable::HashLine
+    include GenomicLocus
+    include Mutation::Filtering
+    def copy
+      self.class.new @hash.clone, @table
     end
 
-    def respond_to? method
-      !@mutation[method.to_sym].nil? || super
+    attr_reader :muts
+    def initialize h, table
+      super h, table
+      @muts = []
     end
 
-    private
-    CHROM_POS=/^[0-9]+$/
-    ALLELE_SEQ=/^([A-Z]+|-)$/
-    def valid_onco_input?
-      @onco_error = []
-      @onco_error.push 'Malformed start position' unless start.to_s =~ MutationSet::Line::CHROM_POS
-      @onco_error.push 'Malformed stop position' unless stop.to_s =~ MutationSet::Line::CHROM_POS
-      @onco_error.push 'Malformed reference allele' unless ref_allele =~ MutationSet::Line::ALLELE_SEQ
-      @onco_error.push 'Malformed alt allele' unless alt_allele =~ MutationSet::Line::ALLELE_SEQ
-      @onco_error.empty?
+    def mut
+      @muts.first
     end
   end
 
-  class Sample
-    include Enumerable
-    attr_reader :samples, :mutation_config, :lines, :preamble_lines
-    attr_accessor :headers
+  class Collection < HashTable
+    attr_reader :mutation_config
     class << self
-      attr_reader :required, :comment
-      def requires *terms
+      attr_reader :required, :optional
+      def requires terms
         @required = terms
       end
 
-      def comments c
-        @comment = c
-      end
-
-      def read(filename,mutation_config=nil)
-        set = new mutation_config, true
-
-        set.load_file filename
-
-        return set
-      end
-    end
-
-    def load_file filename
-      File.foreach(filename) do |l|
-        fields = l.chomp.split(/\t/,-1)
-        if !headers
-          if fields.first.downcase == required.first.downcase
-            enforce_headers fields
-          else
-            preamble_lines.push l
-          end
-          next
-        end
-        add_line fields
+      def might_have terms
+        @optional = terms
       end
 
-      post_read_hook
-    end
-
-    def preamble
-      preamble_lines.join("")
-    end
-
-    def write file
-      File.open(file,"w") do |f|
-        output f
-      end
-    end
-
-    def print f=nil
-      if f
-        write f
-      else
-        output STDOUT
-      end
-    end
-
-    def output f
-      f.puts preamble
-      f.puts headers.join("\t")
-      @lines.each do |l|
-        l = yield l if block_given?
-        next if !l || l.invalid?
-        f.puts format_line(l)
+      def comments c
+        @comment = c
       end
     end
 
-    def format_line l
-      l.to_s
-    end
-
     def clean_header s
       s.to_s.gsub(/\s+/,"_").gsub(/[^\w]+/,"").downcase.to_sym
     end
@@ -259,92 +120,52 @@ module MutationSet
       @headers.map {|h| clean_header h}
     end
 
-    def add_line fields
-      @lines.push self.class.const_get(:Line).new(clean_fields(fields), self)
-
-      index_line @lines.last
-    end
-
-    def clean_fields fields
-      fields.is_a?(Array) ? fields.map{|f| f == "NA" ? "" : f } : fields
-    end
-
-    def index_line line
-      @index[ line.key ] = line
-    end
-
-    def find_mutation line
-      @index[ line.key ]
-    end
-
     def required
-      self.class.required
+      self.class.required.keys
     end
 
-    def enforce_headers array
-      raise "File lacks required headers: #{(required.map(&:downcase)-array.map(&:downcase)).join(", ")}" if !(required.map(&:downcase) - array.map(&:downcase)).empty?
-      @headers = array
+    def initialize(obj=nil,opts={})
+      # get types from required
+      opts[:types] = types_from_required opts
+      super obj, opts
+      @header = required unless @header
+      @mutation_config = YAML.load_file(opts[:mutation_config]) if opts[:mutation_config]
     end
 
-    def initialize(mutation_config=nil,suppress_headers=nil)
-      @lines = []
-
-      @mutation_config = YAML.load_file(mutation_config) if mutation_config
-
-      @headers = required.map(&:to_sym) unless suppress_headers
-
-      @preamble_lines = []
-
-      @index = {}
+    protected
+    def types_from_required opts
+      types = self.class.required ? self.class.required.clone : {}
+      types = types.merge(self.class.optional.clone) if self.class.optional
+      types.merge(opts[:types] || {})
     end
 
-    def whitelist file
-      case file
-      when /.gtf$/
-        require 'gtf'
-        @whitelist ||= GTF.new(file).to_interval_list
-      when /.vcf$/
-        require 'vcf'
-        @whitelist ||= VCF.read(file).to_interval_list
-      end
-      @whitelist
+    def enforce_header
+      create_sleeve
+      raise "File lacks required headers: #{missing_required.join(", ")}" unless missing_required.empty?
     end
 
-    def blacklist file
-      case file
-      when /.gtf$/
-        require 'gtf'
-        @blacklist ||= GTF.new(file).to_interval_list
-      when /.vcf$/
-        require 'vcf'
-        @blacklist ||= VCF.read(file).to_interval_list
+    def create_sleeve
+      @sleeve = @header
+      @header = @header.map do |h|
+        clean_header h
       end
-      @blacklist
+      raise "Headers are not unique: #{duplicate_headers.join(", ")}" unless duplicate_headers.empty?
+      @sleeve = Hash[@header.zip @sleeve]
     end
 
-    def to_interval_list
-      IntervalList.new self.map{|g| [ g.chrom, g.start, g.stop, g ] }
+    def duplicate_headers
+      @header.inject(Hash.new(0)) do |count,h|
+        count[h] += 1
+        count
+      end.select do |h,count|
+        count > 1
+      end.keys
     end
 
-    def inspect
-      to_s
+    def missing_required
+      required - @header.map(&:downcase)
     end
 
-    def [](key)
-      @lines[key]
-    end
-
-    def sort_by! &block
-      @lines.sort_by! &block
-    end
-
-    def each
-      @lines.each do |l|
-        yield l
-      end
-    end
-
-    protected
     def post_read_hook
     end
   end

data/lib/mutect.rb

@@ -2,22 +2,25 @@ require 'oncotator'
 require 'yaml'
 require 'mutation_set'
 
-class MuTect < MutationSet::Sample
-  requires "contig", "position", "context", "ref_allele", "alt_allele",
-    "tumor_name", "normal_name", "score", "dbsnp_site", "covered", "power",
-    "tumor_power", "normal_power", "total_pairs", "improper_pairs",
-    "map_q0_reads", "t_lod_fstar", "tumor_f", "contaminant_fraction",
-    "contaminant_lod", "t_ref_count", "t_alt_count", "t_ref_sum", "t_alt_sum",
-    "t_ref_max_mapq", "t_alt_max_mapq", "t_ins_count", "t_del_count",
-    "normal_best_gt", "init_n_lod", "n_ref_count", "n_alt_count", "n_ref_sum",
-    "n_alt_sum", "judgement"
+class MuTect < Mutation::Collection
+  header_on
+  requires :contig => :str, :position => :int, :context => :str, :ref_allele => :str, :alt_allele => :str,
+    :tumor_name => :str, :normal_name => :str, :score => :float, :dbsnp_site => :str, :covered => :str, :power => :float,
+    :tumor_power => :float, :normal_power => :float, :total_pairs => :int, :improper_pairs => :int,
+    :map_q0_reads => :int, :t_lod_fstar => :float, :tumor_f => :float, :contaminant_fraction => :float,
+    :contaminant_lod => :float, :t_ref_count => :int, :t_alt_count => :int, :t_ref_sum => :int, :t_alt_sum => :int,
+    :t_ref_max_mapq => :int, :t_alt_max_mapq => :int, :t_ins_count => :int, :t_del_count => :int,
+    :normal_best_gt => :str, :init_n_lod => :float, :n_ref_count => :int, :n_alt_count => :int, :n_ref_sum => :int,
+    :n_alt_sum => :int, :judgement => :str
   comments "##"
 
-  class Line < MutationSet::Line
-    alias_key :chrom, :contig
+  class Line < Mutation::Record
+    alias_key :seqname, :contig
+    alias_key :pos, :position
     alias_key :start, :position
-    def stop; @stop || end_position; end
-    def stop= nc; @stop = nc; end
+    alias_key :stop, :default_stop
+    alias_key :ref, :ref_allele
+    alias_key :alt, :alt_allele
     def keep_somatic?
       !criteria_failed?(self, [ :mutect, :somatic ])
     end
@@ -25,10 +28,6 @@ class MuTect < MutationSet::Sample
       !criteria_failed?(self, [ :mutect, :germline ])
     end
 
-    def end_position
-      position.to_i + ref_allele.length-1
-    end
-
     def q0_ratio
       map_q0_reads.to_f / (t_alt_count.to_i + n_alt_count.to_i)
     end
@@ -39,5 +38,11 @@ class MuTect < MutationSet::Sample
     def n_var_freq; n_alt_count.to_f / n_depth end
     def t_depth; t_alt_count.to_i + t_ref_count.to_i end
     def n_depth; n_alt_count.to_i + n_ref_count.to_i end
+
+    def initialize h, table
+      super h, table
+      @muts.push Mutation.new(seqname,pos,ref,alt,t_ref_count,t_alt_count)
+    end
   end
+  line_class MuTect::Line
 end

data/lib/oncotator.rb

@@ -16,7 +16,7 @@ class Oncotator
   end
 
   def self.db_opts
-    @db_opts ||= TaylorlibConfig.get_conf :oncotator
+    @db_opts ||= GermConfig.get_conf :oncotator
   end
 
   def self.db_cache
@@ -142,3 +142,45 @@ class Oncotator
     end
   end
 end
+class Mutation
+  class Record < HashTable::HashLine
+    def skip_oncotator? criteria=nil
+      return true if !mut.onco || mut.onco.empty? || criteria_failed?(mut.onco, criteria || :oncotator)
+    end
+  end
+  module Oncotate
+    def onco
+      raise ArgumentError, @onco_error unless valid_onco_input?
+      @onco ||= Oncotator.new :key => to_ot
+    end
+
+    def discard_onco
+      @onco = nil
+    end
+
+    def inspect
+      "#<#{self.class.name}:#{object_id} @mutation=#{@mutation}>"
+    end
+
+    def in_cosmic
+      onco.Cosmic_overlapping_mutations ? "YES" : "NO"
+    end
+
+    def to_ot
+      [ short_chrom, start, stop, ref, alt ].join("_")
+    end
+
+    private
+    CHROM_POS=/^[0-9]+$/
+    ALLELE_SEQ=/^([A-Z]+|-)$/
+    def valid_onco_input?
+      @onco_error = []
+      #@onco_error.push 'Malformed start position' unless start.to_s =~ Mutation::Oncotate::CHROM_POS
+      #@onco_error.push 'Malformed stop position' unless stop.to_s =~ Mutation::Oncotate::CHROM_POS
+      @onco_error.push 'Malformed reference allele' unless ref =~ Mutation::Oncotate::ALLELE_SEQ
+      @onco_error.push 'Malformed alt allele' unless alt =~ Mutation::Oncotate::ALLELE_SEQ
+      @onco_error.empty?
+    end
+  end
+  include Oncotate
+end

data/lib/sdrf.rb

@@ -0,0 +1,14 @@
+require 'hash_table'
+
+class SDRF < HashTable
+  def initialize file, opts={}
+    @sdrf_header = File.open(file).gets.split(/\t/)
+    super file, :header => [ :extract_name, :tcga_barcode ] + other_headers, :skip_header => true
+  end
+
+  def other_headers
+    @sdrf_header[2..-1].map.with_index do |header,i|
+      "header#{i}".to_sym
+    end
+  end
+end

data/lib/tcga.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+
+require 'hash_table'
+require 'sdrf'
+require 'germ/config'
+
+module TCGA
+  class Sample
+    attr_reader :barcode, :cancer_type
+    def initialize barcode, cancer_type
+      @barcode = barcode
+      @cancer_type = cancer_type
+    end
+  end
+  class RsemExpression
+    def initialize sample
+      @sample = sample
+    end
+    def gene_file
+      exp = sdrf.find do |exp|
+        exp.tcga_barcode == @sample.barcode && exp.header21 == 'RSEM_genes'
+      end
+      File.join(GermConfig.get_conf(:tcga, :cancer_types, @sample.cancer_type, :rsem_exp_raw), exp.header19) if exp
+    end
+    def gene_exp
+      if gene_file
+        @gene_exp ||= HashTable.new gene_file, :header => { :gene_id => :str,
+                                                            :raw_count => :float,
+                                                            :scaled_estimate => :float,
+                                                            :transcript_id => :str },
+                                                :skip_header => true,
+                                                :idx => :gene_id
+      end
+    end
+    def sdrf
+      return @sdrf if @sdrf
+      sdrf_file = GermConfig.get_conf(:tcga, :cancer_types, @sample.cancer_type, :rsem_exp_sdrf)
+      @sdrf = SDRF.new sdrf_file if sdrf_file
+    end
+  end
+end