rbbt-entities 1.0.0 → 1.1.0

data/lib/rbbt/entity.rb

@@ -12,13 +12,14 @@ module Entity
     Entity.formats[base.to_s] = base
     base.module_eval do
       class << self
-        attr_accessor :template
+        attr_accessor :template, :list_template, :action_template, :list_action_template
         alias prev_entity_extended extended
       end
 
       def self.extended(data)
         prev_entity_extended(data)
-        data.extend AnnotatedArray
+        data.extend AnnotatedArray if Array === data
+        data
       end
 
       def self.format=(formats)
@@ -37,6 +38,14 @@ module Entity
         end
       end
 
+      def to_yaml(*args)
+        clean_annotations.to_yaml(*args)
+      end
+
+      def marshal_dump
+        clean_annotations
+      end
+
       def consolidate
         self.inject(nil){|acc,e| 
           if acc.nil?
@@ -54,7 +63,7 @@ module Entity
     when (Hash === name and name.size == 1)
       name, type = name.collect.first
     when (String === name or Symbol === name)
-      type = :both
+      type = :single
     else
       raise "Format of name ( => type) not understood: #{name.inspect}"
     end
@@ -62,61 +71,59 @@ module Entity
     name = name.to_s unless String === name
 
     case type
-    when :both
-      self.module_eval do define_method name, &block end
-    when :array
-      self.module_eval do 
-        ary_name = "_ary_" << name
-        define_method ary_name, &block 
-        define_method name do |*args|
-          raise "Method #{ name } only defined for array" unless Array === self
-          self.send(ary_name, *args)
-        end
-      end
-    when :single
-      self.module_eval do 
-        single_name = "_single_" << name
-        define_method single_name, &block 
-        define_method name do |*args|
-          raise "Method #{ name } not defined for array" if Array === self
-          self.send(single_name, *args)
-        end
-      end
-    when :single2array
+    when :single, :single2array
       self.module_eval do 
         single_name = "_single_" << name
         define_method single_name, &block 
         define_method name do |*args|
           if Array === self
-            collect{|e| e.send(single_name, *args)}
+            self.collect{|e| e.send(name, *args)}
           else
             self.send(single_name, *args)
           end
         end
       end
-    when :array2single
+    when :array, :array2single
       self.module_eval do 
         ary_name = "_ary_" << name
         define_method ary_name, &block 
+
         define_method name do |*args|
           case
           when Array === self
             self.send(ary_name, *args)
           when (Array === self.container and self.container.respond_to? ary_name)
-            res = self.container.send(ary_name, *args)
+            res = self.container.send(name, *args)
             if Hash === res
               res[self]
             else
-              pos = self.container.index self
-              res[pos]
+              res[self.container_index]
             end
           else
             res = self.make_list.send(ary_name, *args)
             Hash === res ? res[self] : res[0]
           end
         end
+
       end
     end
   end
+
+  UNPERSISTED_PREFIX = "entity_unpersisted_property_"
+  def persist(method_name, type = nil, options = {})
+    type = :memory if type.nil?
+
+    self.module_eval do
+      orig_name = UNPERSISTED_PREFIX + method_name.to_s
+      alias_method orig_name, method_name unless instance_methods.include? orig_name
+
+      define_method method_name do |*args|
+        Persist.persist(__method__.to_s, type, options.merge(:other => {:args => args, :id => self.id})) do
+          self.send(orig_name, *args)
+        end
+      end
+    end
+  end
+
 end
 

data/lib/rbbt/entity/gene.rb

@@ -2,103 +2,146 @@ require 'rbbt/entity'
 require 'rbbt/workflow'
 require 'rbbt/sources/organism'
 require 'rbbt/sources/entrez'
+require 'rbbt/sources/matador'
+require 'rbbt/sources/cancer'
 require 'rbbt/entity/protein'
 require 'rbbt/entity/pmid'
+require 'rbbt/entity/transcript'
 
 Workflow.require_workflow "Translation"
 
 module Gene
   extend Entity
 
+  def self.ensg2enst(organism, gene)
+    @@ensg2enst ||= {}
+    @@ensg2enst[organism] ||= Organism.gene_transcripts(organism).tsv(:type => :flat, :key_field => "Ensembl Gene ID", :fields => ["Ensembl Transcript ID"], :persist => true).tap{|o| o.unnamed = true}
+
+    if Array === gene
+      @@ensg2enst[organism].values_at *gene
+    else
+      @@ensg2enst[organism][gene]
+    end
+  end
+
+
+  def self.filter(query, field = nil, options = nil, entity = nil)
+    return true if query == entity
+
+    return true if query == Gene.setup(entity.dup, options.merge(:format => field)).name
+
+    false
+  end
+
   self.annotation :format
   self.annotation :organism
 
   self.format = Organism::Hsa.identifiers.all_fields - ["Ensembl Protein ID", "Ensembl Transcript ID"]
 
+  property :ortholog => :array2single do |other|
+    return self if organism =~ /^#{ other }(?!\w)/
+    new_organism = organism.split(":")
+    new_organism[0] = other
+    new_organism = new_organism * "/"
+    Gene.setup(Organism[organism]["ortholog_#{other}"].tsv(:persist => true).values_at(*self.ensembl).collect{|l| l.first}, "Ensembl Gene ID", new_organism)
+  end
+  persist :ortholog 
+
   property :to! => :array2single do |new_format|
     return self if format == new_format
     Gene.setup(Translation.job(:tsv_translate, "", :organism => organism, :genes => self, :format => new_format).exec.values_at(*self), new_format, organism)
   end
+  persist :to!
 
   property :to => :array2single do |new_format|
     return self if format == new_format
-    to!(new_format).collect!{|v| v.nil? ? nil : v.first}
+    to!(new_format).collect!{|v| Array === v ? v.first : v}
   end
+  persist :to 
+
+  property :strand => :array2single do 
+    Organism.gene_positions(organism).tsv(:fields => ["Strand"], :type => :single, :persist => true).values_at *self
+  end
+  persist :strand
 
   property :ensembl => :array2single do
-    @ensembl ||= to "Ensembl Gene ID"
+    to "Ensembl Gene ID"
   end
+  persist :ensembl
 
   property :entrez => :array2single do
-    @entrez ||= to "Entrez Gene ID"
+    to "Entrez Gene ID"
   end
+  persist :entrez
 
+  property :uniprot => :array2single do
+    to "UniProt/SwissProt Accession"
+  end
+  persist :uniprot
 
   property :name => :array2single do
-    @name ||= to "Associated Gene Name"
+    to "Associated Gene Name"
   end
+  persist :name
 
   property :chr_start => :array2single do
-    @chr_start = begin
-                   Organism.gene_positions(organism).tsv(:persist => true, :type => :single, :cast => :to_i, :fields => ["Gene Start"]).values_at *self
-                 end
+    Organism.gene_positions(organism).tsv(:persist => true, :type => :single, :cast => :to_i, :fields => ["Gene Start"]).values_at *self
   end
+  persist :chr_start
 
   property :go_bp_terms => :array2single do
-    @go_bp_terms ||= Organism.gene_go_bp(organism).tsv(:persist => true, :key_field => "Ensembl Gene ID", :fields => ["GO ID"], :type => :flat).values_at *self.ensembl
+    Organism.gene_go_bp(organism).tsv(:persist => true, :key_field => "Ensembl Gene ID", :fields => ["GO ID"], :type => :flat).values_at *self.ensembl
   end
+  persist :go_bp_terms
 
   property :long_name => :single2array do
     gene = Entrez.get_gene(to("Entrez Gene ID"))
     gene.nil? ? nil : gene.description.flatten.first
   end
+  persist :long_name
 
   property :description => :single2array do
     gene = Entrez.get_gene(to("Entrez Gene ID"))
     gene.nil? ? nil : gene.summary.flatten.first
   end
+  persist :description
 
   property :transcripts => :array2single do
-    gene_transcripts = Organism.gene_transcripts(organism).tsv :persist => true
-    gene_transcripts.unnamed = true
-    res = gene_transcripts.values_at(*self.ensembl)
-    res.each{|l| Transcript.setup(l, "Ensembl Transcript ID", organism)}
+    res = Gene.ensg2enst(organism, self.ensembl)
+    Transcript.setup(res, "Ensembl Transcript ID", organism)
     res
   end
+  persist :transcripts
 
   property :proteins  => :array2single do
-    @proteins ||= begin
-                    transcripts = self.transcripts
-                    all_transcripts = Transcript.setup(transcripts.flatten, "Ensembl Transcript ID", organism)
-                    transcript2protein = nil
+    transcripts = Gene.ensg2enst(organism, self.ensembl)
 
-                    transcript2protein = Misc.process_to_hash(all_transcripts){|list|
-                      list.protein
-                    }
+    all_transcripts = Transcript.setup(transcripts.flatten.compact.uniq, "Ensembl Transcript ID", organism)
 
-                    res = nil
-                    res = transcripts.collect{|list|
-                      Protein.setup(transcript2protein.values_at(*list), "Ensembl Protein ID", organism)
-                    }
+    transcript2protein = Misc.process_to_hash(all_transcripts){|list|
+      list.protein
+    }
+
+    res = transcripts.collect{|list|
+      Protein.setup(transcript2protein.values_at(*list).compact.uniq, "Ensembl Protein ID", organism)
+    }
 
-                    res.each{|l| 
-                    }
-                    res
-                  end
+    Protein.setup(res, "Ensembl Protein ID", organism)
   end
+  persist :proteins
 
   property :max_transcript_length => :array2single do
     transcripts.collect{|list| list.sequence_length.compact.max}
   end
+  persist :max_transcript_length
 
   property :max_protein_length => :array2single do
-    @max_protein_length ||= begin
-                              proteins = self.proteins
-                              all_proteins = Protein.setup(proteins.flatten, "Ensembl Protein ID", organism)
-                              lengths = Misc.process_to_hash(all_proteins){|list| list.sequence_length}
-                              proteins.collect{|list| lengths.values_at(*list).compact.max}
-                            end
+    proteins = self.proteins
+    all_proteins = Protein.setup(proteins.flatten, "Ensembl Protein ID", organism)
+    lengths = Misc.process_to_hash(all_proteins){|list| list.sequence_length}
+    proteins.collect{|list| lengths.values_at(*list).compact.max}
   end
+  persist :max_protein_length
 
   property :chromosome => :array2single do
     chr = Organism.gene_positions(organism).tsv :fields => ["Chromosome Name"], :type => :single, :persist => true
@@ -111,6 +154,7 @@ module Gene
       chr[to("Ensembl Gene ID")]
     end
   end
+  persist :chromosome
 
   property :range => :array2single do
     pos = Organism.gene_positions(organism).tsv :fields => ["Gene Start", "Gene End"], :type => :list, :persist => true, :cast => :to_i
@@ -119,56 +163,88 @@ module Gene
       Range.new *pos[gene]
     end
   end
+  persist :range
 
   property :articles => :array2single do
-    @articles ||= begin
-                    PMID.setup(Organism.gene_pmids(organism).tsv(:persist => true, :fields => ["PMID"], :type => :flat).values_at *self.entrez)
-                  end 
+    PMID.setup(Organism.gene_pmids(organism).tsv(:persist => true, :fields => ["PMID"], :type => :flat, :unnamed => true).values_at *self.entrez)
   end
-end
+  persist :articles
 
-module Transcript
-  extend Entity
+  property :sequence => :array2single do
+    Organism.gene_sequence(organism).tsv :persist => true
+    @gene_sequence.unnamed = true
+    @gene_sequence.values_at *self.ensembl
+  end
+  persist :sequence
 
-  self.annotation :format
-  self.annotation :organism
+  property :matador_drugs => :array2single do
+    @@matador ||= Matador.protein_drug.tsv(:persist => false).tap{|o| o.unnamed = true}
 
-  self.format = "Ensembl Transcript ID"
+    ensg = self._to("Ensembl Gene ID")
 
-  property :to! => :array2single do |new_format|
-    return self if format == new_format
-    Gene.setup(Translation.job(:tsv_probe_translate, "", :organism => organism, :genes => self, :format => new_format).exec.values_at(*self), new_format, organism)
-  end
+    transcripts = Gene.ensg2enst(organism, ensg)
 
-  property :to => :array2single do |new_format|
-    return self if format == new_format
-    to!(new_format).collect!{|v| v.nil? ? nil : v.first}
+    t2ps = Misc.process_to_hash(transcripts.compact.flatten.uniq){|l| Transcript.enst2ensp(organism, l).flatten.compact.uniq}
+
+    all_proteins = t2ps.values.flatten.compact
+
+    chemical_pos = @@matador.identify_field "Chemical"
+
+    p2ds = Misc.process_to_hash(all_proteins){|proteins| 
+      @@matador.values_at(*proteins).collect{|values| 
+        next if values.nil?
+        values[chemical_pos]
+      }
+    }
+
+    res = transcripts.collect do |ts|
+      ps = t2ps.values_at(*ts).compact.flatten
+      p2ds.values_at(*ps).flatten.compact.uniq
+    end
+
+    res
   end
+  persist :matador_drugs
 
-  def ensembl
-    to "Ensembl Transcript ID"
+  property :drugs => :array2single do
+    @matador_drugs = matador_drugs
   end
+  persist :drugs
 
+  property :kegg_pathway_drugs => :array2single do
+    self.collect{|gene|
+      pathway_genes = gene.kegg_pathways
+      next if pathway_genes.nil?
+      pathway_genes = pathway_genes.compact.flatten.genes.flatten
+      Gene.setup(pathway_genes, "KEGG Gene ID", organism)
 
-  property :sequence => :array2single do
-    transcript_sequence = Organism.transcript_sequence(organism).tsv :persist => true
-    transcript_sequence.unnamed = true
-    transcript_sequence.values_at *self.ensembl
+      pathway_genes.compact.drugs.compact.flatten.uniq
+    }
   end
+  persist :kegg_pathway_drugs
 
-  property :sequence_length => :array2single do
-    sequence.collect{|s|
-      s.nil? ? nil : s.length
-    }
+  property :pathway_drugs => :array2single do
+    kegg_pathway_drugs
   end
+  persist :pathway_drugs
 
-  property :protein  => :array2single do
-    transcript_protein = Organism.transcripts(organism).tsv :single, :persist => true, :fields => ["Ensembl Protein ID"]
-    transcript_protein.unnamed = true
+  property :related_cancers => :array2single do
+    Cancer["cancer_genes.tsv"].tsv(:persist => true, :type => :list).values_at(*self.name).collect{|v| v.nil? ? nil : v["Tumour Types (Somatic Mutations)"].split(", ") + v["Tumour Types (Germline Mutations)"].split(", ")}
+  end
+  persist :related_cancers
 
-    res = transcript_protein.values_at(*self.ensembl)
-    Protein.setup(res, "Ensembl Protein ID", organism)
-    res
+  property :somatic_snvs => :array2single do
+    names = self.name
+    raise "No organism defined" if self.organism.nil?
+    clean_organism = self.organism.sub(/\/.*/,'') + '/jun2011'
+    names.organism = clean_organism
+    ranges = names.chromosome.zip(name.range).collect do |chromosome, range|
+      [chromosome, range.begin, range.end] * ":"
+    end
+    Sequence.job(:somatic_snvs_at_genomic_ranges, File.join("Gene", (names.compact.sort * ", ")[0..80]), :organism => clean_organism, :ranges  => ranges).fork.join.load.values_at *ranges
   end
+  persist :somatic_snvs
+
 end
 
+

data/lib/rbbt/entity/genomic_mutation.rb

@@ -16,14 +16,109 @@ module GenomicMutation
 
   self.format = "Genomic Mutation"
 
-  property :score => :single2array do
-    self.split(":")[3].to_f
+  property :guess_watson => :array do
+     if Array === self
+        @watson = Sequence.job(:is_watson, jobname, :mutations => self.clean_annotations, :organism => organism).run
+      else
+        @watson = Sequence.job(:is_watson, jobname, :mutations => [self.clean_annotations], :organism => organism).run
+      end
   end
+  persist :guess_watson
+
+  def watson
+    if @watson.nil?
+      @watson = :missing
+      @watson = guess_watson
+    end
+    @watson
+  end
+
+  def orig_watson
+    @watson
+  end
+
+  property :ensembl_browser => :single2array do
+    "http://#{Misc.ensembl_server(self.organism)}/Homo_sapiens/Location/View?db=core&r=#{chromosome}:#{position - 100}-#{position + 100}"
+  end
+  persist :ensembl_browser
+
+  property :chromosome => :array2single do
+    self.clean_annotations.collect{|mut| mut.split(":")[0]}
+  end
+  persist :chromosome
+
+  property :position => :array2single do
+    self.clean_annotations.collect{|mut| mut.split(":")[1].to_i}
+  end
+  persist :position
+
+  property :base => :array2single do
+    self.clean_annotations.collect{|mut| mut.split(":")[2]}
+  end
+  persist :base
+
+  property :reference => :array2single do
+    Sequence.reference_allele_at_chr_positions(organism, chromosome, position)
+  end
+  persist :reference
 
+  property :score => :array2single do
+    self.clean_annotations.collect{|mut| mut.split(":")[3].to_f}
+  end
+  persist :score
+
+  property :remove_score => :array2single do
+    self.annotate(self.collect{|mut| mut.split(":")[0..2] * ":"})
+  end
+  persist :remove_score
 
-  property :position => :single2array do
-    self.split(":")[1].to_i
+  property :noscore => :single2array do
+    self.annotate self.clean_annotations.collect{|mut| mut.split(":")[0..2]}
+  end
+  persist :noscore
+
+  property :to_watson => :array2single do
+    if watson
+      self
+    else
+      result = Sequence.job(:to_watson, jobname, :mutations => self.clean_annotations, :organism => organism).run 
+      self.annotate(result)
+      result
+    end
+  end
+  persist :to_watson
+
+  property :reference => :array2single do
+    Sequence.job(:reference_allele_at_genomic_positions, jobname, :positions => self.clean_annotations, :organism => organism).run.values_at *self
+  end
+  persist :reference
+
+  property :type => :array2single do
+    self.base.zip(reference).collect do |base,reference|
+      type = case
+             when base == reference
+               "none"
+             when (base.nil? or reference.nil? or base == "?" or reference == "?")
+               "unknown"
+             when (base.length > 1 or base == '-')
+               "indel"
+             when (not %w(A G T C).include? base and not %w(A G T C).include? reference) 
+               nil
+             when (((Misc::IUPAC2BASE[base] || []) & ["A", "G"]).any? and     ((Misc::IUPAC2BASE[reference] || []) & ["A", "G"]).any?)
+               "transition"
+             when (((Misc::IUPAC2BASE[base] || []) & ["T", "C"]).any? and     ((Misc::IUPAC2BASE[reference] || []) & ["T", "C"]).any?)
+               "transition"
+             when (((Misc::IUPAC2BASE[base] || []) & ["A", "G"]).any? and not ((Misc::IUPAC2BASE[reference] || []) & ["A", "G"]).any?)
+               "transversion"
+             when (((Misc::IUPAC2BASE[base] || []) & ["T", "C"]).any? and not ((Misc::IUPAC2BASE[reference] || []) & ["T", "C"]).any?)
+               "transversion"
+             else
+               "unknown [#{[base, reference] * " - "}]"
+             end
+      type
+    end
   end
+  persist :type
 
   property :offset_in_genes => :array2single do
     gene2chr_start = Misc.process_to_hash(genes.flatten){|list| list.chr_start}
@@ -34,60 +129,62 @@ module GenomicMutation
       }.compact
     }
   end
+  persist :offset_in_genes
 
   property :genes => :array2single do
-    @genes ||= begin
-                 genes = Sequence.job(:genes_at_genomic_positions, jobname, :organism => organism, :positions => self).run
-                 genes.unnamed = true
-                 genes = genes.values_at *self
-                 Gene.setup(genes, "Ensembl Gene ID", organism)
-               end
+    genes = Sequence.job(:genes_at_genomic_positions, jobname, :organism => organism, :positions => self.clean_annotations).run
+    genes.unnamed = true
+    genes = genes.values_at *self
+    Gene.setup(genes, "Ensembl Gene ID", organism)
   end
+  persist :genes
 
   property :mutated_isoforms => :array2single do
-    @mutated_isoforms ||= begin
-                            res = Sequence.job(:mutated_isoforms_for_genomic_mutations, jobname, :watson => watson, :organism => organism, :mutations => self).run.values_at *self
-                            res.each{|list| list.organism = organism}
-                            res
-                          end
+    res = Sequence.job(:mutated_isoforms_for_genomic_mutations, jobname, :watson => watson, :organism => organism, :mutations => self.clean_annotations).run.values_at *self
+    res.each{|list| list.organism = organism unless list.nil?}
+    res[0].annotate res if res[0].respond_to? :annotate
+    res
   end
+  persist :mutated_isoforms
 
-  property :exon_junctions do
-    @exon_junctions ||= Sequence.job(:exon_junctions_at_genomic_positions, jobname, :organism => organism, :positions => self).run.values_at *self
+  property :exon_junctions => :array do
+    Sequence.job(:exon_junctions_at_genomic_positions, jobname, :organism => organism, :positions => self.clean_annotations).run.values_at(*self)
   end
+  persist :exon_junctions
 
   property :in_exon_junction? => :array2single do
     exon_junctions.collect{|l| not l.nil? and not l.empty?}
   end
+  persist :in_exon_junction?
 
   property :over_gene? => :array2single do |gene|
-    @over_genes ||= {}
-    @over_genes[gene] ||= genes.clean_annotations.collect{|list| list.include? gene}
-  end
-
-  property :mutation_assessor_scores => :array2single do
-    @mutation_assessor_scores ||= begin
-                                   mutated_isoforms = self.mutated_isoforms
-                                   all_mutated_isoforms = MutatedIsoform.setup(mutated_isoforms.flatten.compact, organism)
-                                   mutated_isoform2damage_score = Misc.process_to_hash(all_mutated_isoforms){|list| all_mutated_isoforms.mutation_assessor_scores}
-
-                                   MutatedIsoform.setup(mutated_isoforms.collect{|list| list.nil? ? [] : mutated_isoform2damage_score.values_at(*list)}, organism)
-                                 end
-  end
-
-  property :truncated do
-    @truncated ||= begin
-                     mutated_isoforms = self.mutated_isoforms
-                     all_mutated_isoforms = MutatedIsoform.setup(mutated_isoforms.flatten.compact, organism)
-                     mutated_isoform2truncated = Misc.process_to_hash(all_mutated_isoforms){|list| all_mutated_isoforms.truncated}
-                     mutated_isoforms.collect{|list| list.nil? ? [] : mutated_isoform2truncated.values_at(*list)}
-                   end
+    if Gene === gene
+      range = gene.range
+      chromosome = gene.chromosome
+    else
+      range = Gene.setup(gene.dup, "Ensembl Gene ID", organism).range
+      chromosome = Gene.setup(gene.dup, "Ensembl Gene ID", organism).chromosome
+    end
+
+    if range.nil?
+      [false] * self.length
+    else
+      chromosome.zip(position).collect{|chr,pos| chr == chromosome and range.include? pos}
+    end
+
+    #genes.clean_annotations.collect{|list| list.include? gene}
   end
 
   property :affected_exons  => :array2single do
-    @affected_exons ||= begin
-                          Sequence.job(:exons_at_genomic_positions, jobname, :organism => organism, :positions => self).run.values_at *self
-                        end
+    Sequence.job(:exons_at_genomic_positions, jobname, :organism => organism, :positions => self.clean_annotations).run.values_at *self
   end
+  persist :affected_exons
 
+  property :damaging? => :array2single do |*args|
+    exon_junctions.zip(mutated_isoforms).collect do |exs, mis|
+      (Array === exs and exs.any?) or
+      (Array === mis and mis.select{|mi| mi.damaged?(*args)}.any?)
+    end
+  end
+  persist :damaging?
 end