rbbt-entities 1.0.0 → 1.1.0

data/lib/rbbt/entity/genotype.rb

@@ -27,10 +27,10 @@ module Genotype
       end
     end
 
-    def self.extended(base)
-      prev_genotype_cohort_extended(base) if self.respond_to? :prev_genotype_cohort_extended
+    def self.extended(cohort)
+      prev_genotype_cohort_extended(cohort) if self.respond_to? :prev_genotype_cohort_extended
 
-      class << base
+      class << cohort
         attr_accessor :metagenotype
 
         def jobname
@@ -43,24 +43,29 @@ module Genotype
 
         def metagenotype
           if @metagenotype.nil?
-            @metagenotype = GenomicMutation.setup(self.dup.flatten, jobname, self[0].organism, self[0].watson)
+            @metagenotype = GenomicMutation.setup(self.dup.flatten, jobname, self[0].organism, self[0].orig_watson)
             @metagenotype.extend Genotype unless Genotype === @metagenotype
           end
           @metagenotype
         end
-      end unless base.respond_to? :metagenotype
+      end unless cohort.respond_to? :metagenotype
 
-      base.each do |genotype| genotype.extend Genotype unless Genotype === genotype end
+      cohort.each do |genotype| genotype.extend Genotype unless Genotype === genotype end
 
-      base.helper :metagenotype do
-        base.metagenotype
+      cohort.helper :metagenotype do
+        cohort.metagenotype
       end
 
-      base.helper :samples do
-        base
+      cohort.helper :samples do
+        cohort
       end
 
-      NamedArray.setup(base, base.collect{|base| base.jobname})
+      NamedArray.setup(cohort, cohort.collect{|genotype| genotype.jobname})
+    end
+
+    def subset(genotypes)
+      new = self.values_at *(genotypes & fields)
+      new.extend Cohort
     end
 
     returns "Ensembl Gene ID"
@@ -70,12 +75,13 @@ module Genotype
     end
 
     returns "Ensembl Gene ID"
-    task :damaged_genes => :array do
+    input :methods, :array, "Predictive methods", [:sift, :mutation_assessor]
+    input :threshold, :float, "from 0 to 1", 0.8
+    task :damaged_genes => :array do |methods, threshold|
       set_info :organism, metagenotype.organism
-      samples.collect{|genotype| genotype.damaged_genes}.flatten.uniq
+      samples.collect{|genotype| genotype.damaged_genes(:methods => methods, :threshold => threshold)}.flatten.uniq
     end
 
-
     returns "Ensembl Gene ID"
     task :recurrent_genes => :array do
       set_info :organism, metagenotype.organism
@@ -86,8 +92,10 @@ module Genotype
 
     %w(damaged_genes recurrent_genes all_affected_genes).each do |name|
       define_method name do |*args|
+        options = args.first
         @cache ||= {}
-        @cache[[name, args]] ||= self.job(name, self.jobname).run
+        key = [name, Misc.hash2md5(options || {})]
+        @cache[key] ||= self.job(name, self.jobname, options || {}).run
       end
     end
 
@@ -119,19 +127,27 @@ module Genotype
   end
 
   returns "Ensembl Gene ID"
-  input :threshold, :float, "from 0 to 1", 0.5
-  task :with_damaged_isoforms => :array do |threshold|
+  task :with_non_synonymous_mutations => :array do
+    set_info :organism, genotype.organism
+    genotype.mutated_isoforms.flatten.compact.reject{|mutated_isoform| ["SYNONYMOUS", "UTR"].include? mutated_isoform.consequence}.transcript.gene.uniq
+  end
+
+  returns "Ensembl Gene ID"
+  input :methods, :array, "Predictive methods", [:sift, :mutation_assessor]
+  input :threshold, :float, "from 0 to 1", 0.8
+  task :with_damaged_isoforms => :array do |methods,threshold|
     set_info :organism, genotype.organism
-    mutated_isoform_damage = Misc.process_to_hash(genotype.mutated_isoforms.flatten.compact){|list| MutatedIsoform.setup(list, genotype.organism).damage_scores}
+    mutated_isoform_damage = Misc.process_to_hash(genotype.mutated_isoforms.flatten.compact){|list| MutatedIsoform.setup(list, genotype.organism).damage_scores(methods)}
     genotype.select{|mutation|  if mutation.mutated_isoforms then mutated_isoform_damage.values_at(*mutation.mutated_isoforms.flatten.compact).select{|score| not score.nil?  and score > threshold}.any? else false; end}.genes.flatten.uniq.clean_annotations
   end
 
   returns "Ensembl Gene ID"
   task :truncated => :array do
     set_info :organism, genotype.organism
-    MutatedIsoform.setup(genotype.mutated_isoforms.flatten.compact, "Hsa/jun2011").
-      select{|isoform_mutation| isoform_mutation.truncated }.
-      protein.gene.to("Ensembl Gene ID").uniq.clean_annotations
+    truncated_isoforms = MutatedIsoform.setup(genotype.mutated_isoforms.flatten.compact, "Hsa/jun2011").select{|isoform_mutation| isoform_mutation.truncated }
+    proteins = truncated_isoforms.protein
+    genes = proteins.gene
+    genes.to("Ensembl Gene ID").uniq.clean_annotations
   end
 
   returns "Ensembl Gene ID"
@@ -152,10 +168,12 @@ module Genotype
     (with_damaged_isoforms + truncated + affected_exon_junctions).uniq
   end
 
-  %w(all_affected_genes damaged_genes truncated with_damaged_isoforms affected_exon_junctions long_genes recurrent_genes).each do |name|
+  %w(all_affected_genes damaged_genes truncated with_damaged_isoforms with_non_synonymous_mutations affected_exon_junctions long_genes recurrent_genes).each do |name|
     define_method name do |*args|
+      options = args.first
       @cache ||= {}
-      @cache[[name, args]] ||= self.job(name, self.jobname).run
+      key = [name, Misc.hash2md5(options || {})]
+      @cache[key] ||= self.job(name, self.jobname, options || {}).run
     end
   end
 end

data/lib/rbbt/entity/misc.rb

@@ -3,24 +3,3 @@ require 'rbbt/workflow'
 require 'rbbt/sources/go'
 require 'rbbt/sources/organism'
 require 'rbbt/entity/gene'
-
-module GOTerm
-  extend Entity
-  self.annotation :organism
-
-  self.format = ["GO Term", "GO ID"]
-
-  def name
-    if Array === self
-      self.collect{|id| GO.id2name(id)}
-    else
-      GO.id2name(self)
-    end
-  end
-
-  def genes
-    go2genes = Organism.gene_go(organism).tsv(:key_field => "GO ID", :fields => ["Ensembl Gene ID"], :merge => true, :persist => true)
-    go2genes.unnamed = true
-    Gene.setup(go2genes[self].first, "Ensembl Gene ID", organism)
-  end
-end

data/lib/rbbt/entity/mutated_isoform.rb

@@ -4,6 +4,7 @@ require 'rbbt/sources/organism'
 require 'rbbt/mutation/mutation_assessor'
 require 'rbbt/mutation/sift'
 require 'rbbt/entity/protein'
+require 'rbbt/sources/uniprot'
 require 'rbbt/entity/gene'
 require 'nokogiri'
 
@@ -13,31 +14,41 @@ module MutatedIsoform
 
   self.format = "Mutated Isoform"
 
-  property :protein do
-    if Array === self
-      Protein.setup(self.collect{|mutation| mutation.split(":").first}, "Ensembl Protein ID", organism)
-    else
-      Protein.setup(self.split(":").first, "Ensembl Protein ID", organism)
-    end
+  property :protein => :array2single do
+    Protein.setup(self.collect{|mutation| mutation.split(":").first if mutation =~ /^ENSP/}, "Ensembl Protein ID", organism)
   end
+  persist :protein
 
-  property :change => :single2array do
-    self.split(":").last
+  property :transcript => :array2single do
+    begin
+      protein = self.protein
+      Transcript.setup(protein.transcript.zip(self.collect{|mutation| mutation.split(":").first}).collect{|p| p.compact.first}, "Ensembl Transcript ID", organism)
+    end
   end
+  persist :transcript
 
-  property :position => :single2array do
-    if change.match(/[^\d](\d+)[^\d]/)
-      $1.to_i
-    else
-      nil
-    end
+  property :change => :array2single do
+    self.collect{|mi| mi.split(":").last}
+  end
+  persist :change
+
+  property :position => :array2single do
+    change.collect{|c|
+      if c.match(/[^\d](\d+)[^\d]/)
+        $1.to_i
+      else
+        nil
+      end
+    }
   end
-  
+  persist :position
+
   property :ensembl_protein_image_url => :single2array do
     ensembl_url = if organism == "Hsa" then "www.ensembl.org" else "#{organism.sub(/.*\//,'')}.archive.ensembl.org" end
     "http://#{ensembl_url}/Homo_sapiens/Component/Transcript/Web/TranslationImage?db=core;p=#{protein};_rmd=d2a8;export=svg"
   end
- 
+  persist :ensembl_protein_image_url
+
   property :marked_svg => :single2array do
     svg = Open.read(protein.ensembl_protein_image_url)
     seq_len = protein.sequence_length
@@ -56,10 +67,11 @@ module MutatedIsoform
       svg
     end
   end
+  persist :marked_svg
 
   ASTERISK = "*"[0]
   CONSECUENCES = %w(UTR SYNONYMOUS NOSTOP MISS-SENSE INDEL FRAMESHIFT NONSENSE)
-  property :consecuence => :single2array do
+  property :consequence => :single2array do
     prot, change = self.split(":")
 
     case
@@ -79,14 +91,15 @@ module MutatedIsoform
       "MISS-SENSE"
     end
   end
+  persist :consequence
 
   property :truncated => :array2single do
-    @truncated ||= begin
-                     protein2sequence_length = Misc.process_to_hash(self.protein.flatten){|list| list.sequence_length}
-                     self.collect do |isoform_mutation|
+    begin
+      protein2sequence_length = Misc.process_to_hash(self.protein.flatten){|list| list.sequence_length}
+      self.collect do |isoform_mutation|
 
-                       next if isoform_mutation.consecuence != "FRAMESHIFT" and isoform_mutation.consecuence != "NONSENSE"
-                       protein = isoform_mutation.protein
+                       next if isoform_mutation.consequence != "FRAMESHIFT" and isoform_mutation.consequence != "NONSENSE"
+                       protein  = isoform_mutation.protein
                        position = isoform_mutation.position
                        sequence_length = protein2sequence_length[protein]
 
@@ -100,80 +113,124 @@ module MutatedIsoform
                        end
                      end
                    end
-
   end
-
-  property :damage_scores => :array2single do
-    @damage_scores ||= begin
-                         sift_scores.zip(mutation_assessor_scores).collect{|p|
-                           p = p.compact
-                           if p.empty?
-                             nil
-                           else
-                             p.inject(0.0){|acc, e| acc += e} / p.length
-                           end
-                         }
-                       end
+  persist :truncated
+
+  property :damage_scores => :array2single do |*args|
+    begin
+      methods = args.first
+      methods = [:sift, :mutation_assessor] if methods.nil?
+      methods = [methods] unless Array === methods
+      values = methods.collect{|method|
+        case method.to_sym
+        when :sift
+          sift_scores
+        when :mutation_assessor
+          mutation_assessor_scores
+        else
+          raise "Unknown predictive method: #{ method }"
+        end
+      }
+      if values.compact.empty?
+        return [nil] * self.length
+      else
+        scores = values.shift
+        scores = scores.zip(*values)
+
+        scores.collect{|p|
+          p = p.compact
+          if p.empty?
+            nil
+          else
+            p.inject(0.0){|acc, e| acc += e} / p.length
+          end
+        }
+      end
+    end
+  end
+  persist :damage_scores
+
+  property :damaged? => :array2single do |*args|
+    begin
+      methods, threshold = args
+      threshold     = 0.8 if threshold.nil?
+      damage_scores = self.damage_scores(methods)
+      truncated     = self.truncated
+      damage_scores.zip(truncated).collect{|damage, truncated| truncated or (not damage.nil? and damage > threshold) }
+    end
   end
+  persist :damaged?
 
   property :sift_scores => :array2single do
-    @sift_scores ||= begin
-                       missense = self.select{|iso_mut| iso_mut.consecuence == "MISS-SENSE"}
+    begin
+      missense = self.select{|iso_mut| iso_mut.consequence == "MISS-SENSE"}
 
-                       values = SIFT.chunked_predict(missense).values_at(*self).collect{|v|
-                         v.nil? ? nil : v["Prediction"]
-                       }
+      values = SIFT.chunked_predict(missense).values_at(*self).collect{|v|
+        v.nil? ? nil : 1.0 - v["Score 1"].to_f
+      }
 
-                       range = {nil => nil,
-                         ""  => nil,
-                         "TOLERATED" => 0,
-                         "*DAMAGING" => 1,
-                         "DAMAGING" => 1}
+      values
 
-                       range.values_at *values
-                     end
+      #range = {nil => nil,
+      #  ""  => nil,
+      #  "TOLERATED" => 0,
+      #  "*DAMAGING" => 1,
+      #  "DAMAGING" => 1}
+
+      #range.values_at *values
+    end
   end
+  persist :sift_scores
 
   property :mutation_assessor_scores => :array2single do
-    @mutation_assesor_scores ||= begin
-                                   missense = self.select{|mutation| mutation.consecuence == "MISS-SENSE"}
-
-                                   correspondance = {}
-                                   list = missense.zip(missense.protein.to "UniProt/SwissProt ID").collect do |mutation, uniprot|
-                                     prot, change = mutation.split(":")
-                                     next if uniprot.nil?
-                                     uniprot_change = [uniprot, change]
-                                     correspondance[uniprot_change] ||= []
-                                     correspondance[uniprot_change] << mutation
-                                     uniprot_change
-                                   end.compact
-
-                                   #return TSV.setup({}, :key_field => "Mutated Isoform", :fields => ["Func. Impact"], :type => :list) if list.empty?
-                                   return [nil] * self.length if list.empty?
-
-                                   tsv = MutationAssessor.chunked_predict(list.sort_by{|p| p * "_"})
-
-                                   #return TSV.setup({}, :key_field => "Mutated Isoform", :fields => ["Func. Impact"], :type => :list) if tsv.nil? or tsv.empty? 
-                                   return [nil] * self.length if tsv.empty?
-
-                                   new = TSV.setup({}, :key_field => "Mutated Isoform", :fields => ["Func. Impact"], :type => :list)
-
-                                   tsv.each do |key, values|
-                                     correspondance[key.split(" ")].each do |mutation|
-                                       new[mutation] = values["Func. Impact"]
-                                     end
-                                   end
-
-
-                                   range = {nil => nil,
-                                            ""  => nil,
-                                            "neutral" => 0,
-                                            "low" => 0.3,
-                                            "medium" => 0.6,
-                                            "high" => 1}
-
-                                   range.values_at *new.values_at(*self)
-                                 end
+    begin
+      missense = self.select{|mutation| mutation.consequence == "MISS-SENSE"}
+
+      correspondance = {}
+      list = missense.zip(missense.protein.to "UniProt/SwissProt ID").collect do |mutation, uniprot|
+        prot, change = mutation.split(":")
+        next if uniprot.nil?
+        uniprot_change = [uniprot.upcase, change.upcase]
+        correspondance[uniprot_change] ||= []
+        correspondance[uniprot_change] << mutation
+        uniprot_change
+      end.compact
+
+      #return TSV.setup({}, :key_field => "Mutated Isoform", :fields => ["Func. Impact"], :type => :list) if list.empty?
+      return [nil] * self.length if list.empty?
+
+      tsv = MutationAssessor.chunked_predict(list.sort_by{|p| p * "_"})
+
+      #return TSV.setup({}, :key_field => "Mutated Isoform", :fields => ["Func. Impact"], :type => :list) if tsv.nil? or tsv.empty? 
+      return [nil] * self.length if tsv.empty?
+
+      new = TSV.setup({}, :key_field => "Mutated Isoform", :fields => ["Func. Impact"], :type => :list)
+
+      tsv.each do |key, values|
+        uniprot, change = key.split(" ")
+        uniprot_change = [uniprot.upcase, change.upcase]
+        correspondance[uniprot_change].each do |mutation|
+          new[mutation] = values["Func. Impact"]
+        end
+      end
+
+
+      range = {nil => nil,
+        ""  => nil,
+        "neutral" => 0,
+        "low" => 0.5,
+        "medium" => 0.7,
+        "high" => 1.0}
+
+      range.values_at *new.values_at(*self)
+    end
   end
+  persist :mutation_assessor_scores
 
+  property :pdbs => :single do
+    uniprot = self.transcript.protein.uniprot
+    next if uniprot.nil?
+    Uniprot.pdbs_covering_aa_position(uniprot, self.position)
+  end
+  persist :pdbs
 end

data/lib/rbbt/entity/pmid.rb

@@ -6,14 +6,24 @@ module PMID
 
   self.format = "PMID"
 
+  property :article => :array2single do
+    PubMed.get_article(self).values_at(*self)
+  end
+  persist :article
+
   property :title => :array2single do
-    @title ||= begin
-                 PubMed.get_article(self).values_at(*self).collect{|article| article.nil? ? nil : article.title}
-               end
+    article.collect{|a| a.nil? ? nil : a.title}
+  end
+  persist :title
+
+  property :text => :array2single do
+    article.collect{|a| a.nil? ? nil : a.text}
   end
+  persist :text 
 
   property :pubmed_url => :single2array do
     "<a class='pmid' href='http://www.ncbi.nlm.nih.gov/pubmed/#{self}'>#{ self }</a>"
   end
+  persist :pubmed_url 
 end