rbbt-entities 0.1.0 → 1.0.0

data/lib/rbbt/entity.rb

@@ -27,6 +27,95 @@ module Entity
           Entity.formats[format] = self
         end
       end
+
+      def clean_annotations
+        case
+        when Array === self
+          self.annotated_array_clean_collect{|e| e.respond_to?(:clean_annotations)? e.clean_annotations : e}
+        when String === self
+          "" << self
+        end
+      end
+
+      def consolidate
+        self.inject(nil){|acc,e| 
+          if acc.nil?
+            acc = e
+          else
+            acc.concat e
+          end
+        }
+      end
+    end
+  end
+
+  def property(name, &block)
+    case
+    when (Hash === name and name.size == 1)
+      name, type = name.collect.first
+    when (String === name or Symbol === name)
+      type = :both
+    else
+      raise "Format of name ( => type) not understood: #{name.inspect}"
+    end
+
+    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
+      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)}
+          else
+            self.send(single_name, *args)
+          end
+        end
+      end
+    when :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)
+            if Hash === res
+              res[self]
+            else
+              pos = self.container.index self
+              res[pos]
+            end
+          else
+            res = self.make_list.send(ary_name, *args)
+            Hash === res ? res[self] : res[0]
+          end
+        end
+      end
     end
   end
 end

data/lib/rbbt/entity/cnv.rb

@@ -0,0 +1,37 @@
+require 'rbbt/entity'
+require 'rbbt/workflow'
+require 'rbbt/sources/organism'
+require 'rbbt/entity/gene'
+
+Workflow.require_workflow "Sequence"
+
+module CNV
+  extend Entity
+  self.annotation :jobname
+  self.annotation :organism
+
+  self.format = "Copy Number Variation"
+
+  property :variation => :single2array do
+    self.split(":").last
+  end
+
+  property :loss? => :array2single do
+    @loss ||= self.variation.collect{|v| v =~/loss/i}
+  end
+
+  property :gain? => :array2single do
+    @gain ||= self.variation.collect{|v| v =~/gain/i}
+  end
+
+  property :genes => :array2single do
+    @genes ||= begin
+                 genes = Sequence.job(:genes_at_genomic_ranges, jobname, :organism => organism, :ranges => self).run
+                 genes.unnamed = true
+                 genes = genes.values_at *self
+                 Gene.setup(genes, "Ensembl Gene ID", organism)
+               end
+  end
+
+end
+ 

data/lib/rbbt/entity/gene.rb

@@ -2,6 +2,8 @@ require 'rbbt/entity'
 require 'rbbt/workflow'
 require 'rbbt/sources/organism'
 require 'rbbt/sources/entrez'
+require 'rbbt/entity/protein'
+require 'rbbt/entity/pmid'
 
 Workflow.require_workflow "Translation"
 
@@ -11,50 +13,96 @@ module Gene
   self.annotation :format
   self.annotation :organism
 
-  self.format = Organism::Hsa.identifiers.all_fields
+  self.format = Organism::Hsa.identifiers.all_fields - ["Ensembl Protein ID", "Ensembl Transcript ID"]
 
-  def name
-    to "Associated Gene Name"
+  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
 
-  def description
-    if Array === self
-      to("Entrez Gene ID").collect{|id| gene = Entrez.get_gene(id); gene.nil? ? nil : gene.summary}
-    else
-      gene = Entrez.get_gene(to("Entrez Gene ID"))
-      gene.nil? ? nil : gene.summary
-    end
+  property :to => :array2single do |new_format|
+    return self if format == new_format
+    to!(new_format).collect!{|v| v.nil? ? nil : v.first}
   end
 
-  def to!(new_format)
-    if Array === self
-      Gene.setup(Translation.job(:tsv_translate, "", :organism => organism, :genes => self, :format => new_format).exec.values_at(*self), new_format, organism)
-    else
-      Gene.setup(Translation.job(:tsv_translate, "", :organism => organism, :genes => [self], :format => new_format).exec[self], new_format, organism)
-    end
+  property :ensembl => :array2single do
+    @ensembl ||= to "Ensembl Gene ID"
   end
 
-  def to(new_format)
-    return self if format == new_format
-    if Array === self
-      to!(new_format).collect!{|v| v.nil? ? nil : v.first}
-    else
-      v = to!(new_format)
-      v.nil? ? nil : v.first
-    end
+  property :entrez => :array2single do
+    @entrez ||= to "Entrez Gene ID"
   end
 
-  def self2pfam
-    index = Organism.gene_pfam(organism).tsv :type => :flat, :persist => true
-    if Array === self
-      index.values_at(*self).flatten
-    else
-      index[self]
-    end
+
+  property :name => :array2single do
+    @name ||= to "Associated Gene Name"
+  end
+
+  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
+  end
+
+  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
+  end
+
+  property :long_name => :single2array do
+    gene = Entrez.get_gene(to("Entrez Gene ID"))
+    gene.nil? ? nil : gene.description.flatten.first
+  end
+
+  property :description => :single2array do
+    gene = Entrez.get_gene(to("Entrez Gene ID"))
+    gene.nil? ? nil : gene.summary.flatten.first
+  end
+
+  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
+  end
+
+  property :proteins  => :array2single do
+    @proteins ||= begin
+                    transcripts = self.transcripts
+                    all_transcripts = Transcript.setup(transcripts.flatten, "Ensembl Transcript ID", organism)
+                    transcript2protein = nil
+
+                    transcript2protein = Misc.process_to_hash(all_transcripts){|list|
+                      list.protein
+                    }
+
+                    res = nil
+                    res = transcripts.collect{|list|
+                      Protein.setup(transcript2protein.values_at(*list), "Ensembl Protein ID", organism)
+                    }
+
+                    res.each{|l| 
+                    }
+                    res
+                  end
   end
 
-  def chromosome
+  property :max_transcript_length => :array2single do
+    transcripts.collect{|list| list.sequence_length.compact.max}
+  end
+
+  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
+  end
+
+  property :chromosome => :array2single do
     chr = Organism.gene_positions(organism).tsv :fields => ["Chromosome Name"], :type => :single, :persist => true
+    chr.unnamed = true
     if Array === self
       to("Ensembl Gene ID").collect do |gene|
         chr[gene]
@@ -64,39 +112,63 @@ module Gene
     end
   end
 
-  def range
+  property :range => :array2single do
     pos = Organism.gene_positions(organism).tsv :fields => ["Gene Start", "Gene End"], :type => :list, :persist => true, :cast => :to_i
-    if Array === self
-      to("Ensembl Gene ID").collect do |gene|
-        next if not pos.include? gene
-        Range.new *pos[gene]
-      end
-    else
-      return nil if not pos.include? to("Ensembl Gene ID")
-      Range.new *pos[to("Ensembl Gene ID")]
+    to("Ensembl Gene ID").collect do |gene|
+      next if not pos.include? gene
+      Range.new *pos[gene]
     end
   end
 
+  property :articles => :array2single do
+    @articles ||= begin
+                    PMID.setup(Organism.gene_pmids(organism).tsv(:persist => true, :fields => ["PMID"], :type => :flat).values_at *self.entrez)
+                  end 
+  end
 end
 
 module Transcript
   extend Entity
 
-  def to!(new_format)
-    if Array === self
-      Gene.setup(Translation.job(:tsv_probe_translate, "", :organism => organism, :genes => self, :format => new_format).exec.values_at(*self), new_format, organism)
-    else
-      Gene.setup(Translation.job(:tsv_probe_translate, "", :organism => organism, :genes => [self], :format => new_format).exec[self], new_format, organism)
-    end
+  self.annotation :format
+  self.annotation :organism
+
+  self.format = "Ensembl Transcript 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
 
-  def to(new_format)
+  property :to => :array2single do |new_format|
     return self if format == new_format
-    if Array === self
-      to!(new_format).collect{|v| v.nil? ? nil : v.first}
-    else
-      v = to!(new_format)
-      v.nil? ? nil : v.first
-    end
+    to!(new_format).collect!{|v| v.nil? ? nil : v.first}
+  end
+
+  def ensembl
+    to "Ensembl Transcript ID"
+  end
+
+
+  property :sequence => :array2single do
+    transcript_sequence = Organism.transcript_sequence(organism).tsv :persist => true
+    transcript_sequence.unnamed = true
+    transcript_sequence.values_at *self.ensembl
+  end
+
+  property :sequence_length => :array2single do
+    sequence.collect{|s|
+      s.nil? ? nil : s.length
+    }
+  end
+
+  property :protein  => :array2single do
+    transcript_protein = Organism.transcripts(organism).tsv :single, :persist => true, :fields => ["Ensembl Protein ID"]
+    transcript_protein.unnamed = true
+
+    res = transcript_protein.values_at(*self.ensembl)
+    Protein.setup(res, "Ensembl Protein ID", organism)
+    res
   end
 end
+

data/lib/rbbt/entity/genomic_mutation.rb

@@ -0,0 +1,93 @@
+require 'rbbt/entity'
+require 'rbbt/workflow'
+require 'rbbt/sources/organism'
+require 'rbbt/mutation/mutation_assessor'
+require 'rbbt/entity/protein'
+require 'rbbt/entity/gene'
+require 'rbbt/entity/mutated_isoform'
+
+Workflow.require_workflow "Sequence"
+
+module GenomicMutation
+  extend Entity
+  self.annotation :jobname
+  self.annotation :organism
+  self.annotation :watson
+
+  self.format = "Genomic Mutation"
+
+  property :score => :single2array do
+    self.split(":")[3].to_f
+  end
+
+
+  property :position => :single2array do
+    self.split(":")[1].to_i
+  end
+
+  property :offset_in_genes => :array2single do
+    gene2chr_start = Misc.process_to_hash(genes.flatten){|list| list.chr_start}
+    position.zip(genes).collect{|position, list|
+      list.collect{|gene|
+        next if not gene2chr_start.include? gene
+        [gene, position.to_i - gene2chr_start[gene]] * ":"
+      }.compact
+    }
+  end
+
+  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
+  end
+
+  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
+  end
+
+  property :exon_junctions do
+    @exon_junctions ||= Sequence.job(:exon_junctions_at_genomic_positions, jobname, :organism => organism, :positions => self).run.values_at *self
+  end
+
+  property :in_exon_junction? => :array2single do
+    exon_junctions.collect{|l| not l.nil? and not l.empty?}
+  end
+
+  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
+  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
+  end
+
+end

data/lib/rbbt/entity/genotype.rb

@@ -1,186 +1,162 @@
-require 'rbbt/entity'
 require 'rbbt/workflow'
-require 'rbbt/sources/organism'
-require 'rbbt/mutation/mutation_assessor'
-require 'rbbt/entity/protein'
-
-Workflow.require_workflow "Sequence"
-
-module MutatedIsoform
-  extend Entity
-  self.annotation :organism
+require 'rbbt/entity'
+require 'rbbt/entity/genomic_mutation'
 
-  self.format = "Mutated Isoform"
+module Genotype
+  extend Workflow
 
-  def protein
-    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)
+  if self.respond_to? :extended
+    class << self
+      alias prev_genotype_extended extended
     end
   end
 
-  def ensembl_protein_image_url
-    if Array === self
-      self.collect{|e| e.ensembl_protein_image_url}
-    else
-      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"
+  def self.extended(base)
+    prev_genotype_extended(base) if self.respond_to? :prev_genotype_extended
+    base.helper :genotype do
+      base
     end
   end
 
-  ASTERISK = "*"[0]
-  def single_type
-    prot, change = self.split(":")
-
-    case
-    when change =~ /UTR/
-      "UTR"
-    when (change[0] == ASTERISK and not change[0] == change[-1])
-      "NOSTOP"
-    when (change[-1] == ASTERISK and not change[0] == change[-1])
-      "NONSENSE"
-    when change =~ /Indel/
-      "INDEL"
-    when change =~ /FrameShift/
-      "FRAMESHIFT"
-    when change[0] == change[-1]
-      "SYNONYMOUS"
-    else
-      "MISS-SENSE"
-    end
-  end
-
-  def ary_type
-    self.collect{|mutation| mutation.single_type}
-  end
-
+  module Cohort
+    extend Workflow
 
-  def type
-    Array === self ? ary_type : single_type
-  end
-
-  def filter(*types)
-    list = self.zip(type).select do |mutation, type|
-      types.include? type
-    end.collect{|mutation, type| mutation}
-
-    MutatedIsoform.setup(list, organism)
-  end
-
-  def self2mutation_assessor_prediction
-    if Array === self
-      filtered = filter "MISS-SENSE"
-      correspondance = {}
-      mutations = filtered.zip(filtered.protein.to "UniProt/SwissProt ID").collect do |mutation, uniprot|
-        prot, change = mutation.split(":")
-        next if uniprot.nil?
-        uniprot_change = [uniprot, change]
-        correspondance[uniprot_change] = mutation
-        uniprot_change
-      end.compact
-
-      tsv = MutationAssessor.chunked_predict(mutations)
-      return TSV.setup({}, :key_field => "Mutated Isoform", :fields => ["Func. Impact"]) if tsv.empty?
-      tsv.add_field "Mutated Isoform" do |key, values|
-        correspondance[key.split(" ")]
+    if self.respond_to? :extended
+      class << self
+        alias prev_genotype_cohort_extended extended
       end
-      tsv.reorder "Mutated Isoform", ["Func. Impact"]
-    else
-      prot, change = mutation.split(":")
-      uniprot = protein.to "UniProt/SwissProt ID"
-      mutations = [uniprot, change]
-
-      tsv = MutationAssessor.chunked_predict(mutations)
-      tsv.add_field "Mutated Isoform" do |key, values|
-        self
-      end
-      tsv.reorder "Mutated Isoform", ["Func. Impact"]
     end
-  end
 
-  def early_nonsense
-    protein_sequences = Organism.protein_sequence(organism).tsv :persist => true, :type => :single
-    filter("NONSENSE").select{|isoform_mutation|
-      protein, mutation = isoform_mutation.split ":"
-      if protein_sequences.include? protein
-        mutation.match(/(\d+)/)[1].to_f < protein_sequences[protein].length.to_f * 0.7
-      else
-        false
+    def self.extended(base)
+      prev_genotype_cohort_extended(base) if self.respond_to? :prev_genotype_cohort_extended
+
+      class << base
+        attr_accessor :metagenotype
+
+        def jobname
+          if @jobname.nil?
+            @jobname ||= "Meta-genotype: " + self.collect{|g| g.jobname} * ", "
+            @jobname[100..-1] = " (etc; #{self.length} genotypes)" if @jobname.length > 100
+          end
+          @jobname
+        end
+
+        def metagenotype
+          if @metagenotype.nil?
+            @metagenotype = GenomicMutation.setup(self.dup.flatten, jobname, self[0].organism, self[0].watson)
+            @metagenotype.extend Genotype unless Genotype === @metagenotype
+          end
+          @metagenotype
+        end
+      end unless base.respond_to? :metagenotype
+
+      base.each do |genotype| genotype.extend Genotype unless Genotype === genotype end
+
+      base.helper :metagenotype do
+        base.metagenotype
       end
-    }
-  end
 
-  def early_frameshifts
-    protein_sequences = Organism.protein_sequence(organism).tsv :persist => true, :type => :single
-    filter("FRAMESHIFT").select{|isoform_mutation|
-      protein, mutation = isoform_mutation.split ":"
-      if protein_sequences.include? protein
-        mutation.match(/(\d+)/)[1].to_f < protein_sequences[protein].length.to_f * 0.7
-      else
-        false
+      base.helper :samples do
+        base
       end
-    }
-  end
 
-  def damaged(options = {})
-    options = Misc.add_defaults options, :mutation_assesor_cutoff => :medium, :non_sense => true, :frameshift => true
+      NamedArray.setup(base, base.collect{|base| base.jobname})
+    end
+
+    returns "Ensembl Gene ID"
+    task :all_affected_genes => :array do
+      set_info :organism, metagenotype.organism
+      samples.collect{|genotype| genotype.all_affected_genes}.flatten.uniq
+    end
 
-    levels = [:low, :medium, :high].collect{|v| v.to_s}
-    cutoff = levels.index options[:mutation_assesor_cutoff].to_s
+    returns "Ensembl Gene ID"
+    task :damaged_genes => :array do
+      set_info :organism, metagenotype.organism
+      samples.collect{|genotype| genotype.damaged_genes}.flatten.uniq
+    end
+
+
+    returns "Ensembl Gene ID"
+    task :recurrent_genes => :array do
+      set_info :organism, metagenotype.organism
+      count = Hash.new(0)
+      samples.each do |genotype| genotype.genes.flatten.uniq.each{|gene| count[gene] += 1} end
+      count.select{|gene, c| c > 1}.collect{|gene,c| gene.dup}
+    end
 
-    predicted = self2mutation_assessor_prediction.select{|k, v| 
-      if v.nil?
-        false
-      else
-        value = levels.index(v[0].to_s)
-        value and value >= cutoff
+    %w(damaged_genes recurrent_genes all_affected_genes).each do |name|
+      define_method name do |*args|
+        @cache ||= {}
+        @cache[[name, args]] ||= self.job(name, self.jobname).run
       end
-    }.collect{|k,v| k}
+    end
 
-    predicted += early_nonsense if options[:non_sense]
-    predicted += early_frameshifts if options[:frameshift]
+  end
 
-    MutatedIsoform.setup(predicted, organism)
+  returns "Ensembl Gene ID"
+  task :all_affected_genes => :array do 
+    set_info :organism, genotype.organism
+    genotype.genes.clean_annotations.flatten.uniq
   end
-end
 
-module GenomicMutation
-  extend Entity
-  self.annotation :name
-  self.annotation :organism
+  dep :all_affected_genes
+  returns "Ensembl Gene ID"
+  task :long_genes => :array do
+    all_affected_genes = step(:all_affected_genes).load
+    long_genes = all_affected_genes.select{|gene| 
+      length = gene.max_protein_length
+      length and length > 1000 or gene.name =~ /^PCDH/
+    }
 
-  self.format = "Genomic Mutation"
+    set_info :organism, genotype.organism
+    long_genes.clean_annotations
+  end
 
-  def self2genes
-    Sequence.job(:genes_at_genomic_positions, name, :organism => organism, :positions => Array === self ? self : [self]).run
+  returns "Ensembl Gene ID"
+  task :mutations_in_exon_junctions => :array do
+    set_info :organism, genotype.organism
+    genotype.select{|mutation| mutation.in_exon_junction?}.clean_annotations
   end
 
-  def genes
-    Gene.setup(self2genes.values.flatten.uniq, "Ensembl Gene ID", organism)
+  returns "Ensembl Gene ID"
+  input :threshold, :float, "from 0 to 1", 0.5
+  task :with_damaged_isoforms => :array do |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}
+    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
 
-  def self2mutated_isoforms
-    Sequence.job(:mutated_isoforms_for_genomic_mutations, name, :organism => organism, :mutations => Array === self ? self : [self]).run
+  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
   end
 
-  def mutated_isoforms
-    MutatedIsoform.setup(self2mutated_isoforms.values.flatten, organism)
+  returns "Ensembl Gene ID"
+  task :affected_exon_junctions => :array do
+    set_info :organism, genotype.organism
+    genotype.select{|mutation| mutation.in_exon_junction?}.genes.flatten.clean_annotations
   end
 
-  def damaging_mutations(options = {})
-    damaged_isoforms = mutated_isoforms.damaged(options)
-    damaging_mutations = self2mutated_isoforms.select{|mutation, values|
-      mutated_isoforms = values["Mutated Isoform"]
-      (damaged_isoforms & mutated_isoforms).any?
-    }.collect{|mutation, mutated_isoforms| mutation.dup}
-    GenomicMutation.setup(damaging_mutations, name + '.damaging', organism)
+  dep :with_damaged_isoforms, :truncated, :affected_exon_junctions
+  returns "Ensembl Gene ID"
+  task :damaged_genes => :array do
+    set_info :organism, genotype.organism
+
+    with_damaged_isoforms   = step(:with_damaged_isoforms).load.clean_annotations
+    truncated               = step(:truncated).load.clean_annotations
+    affected_exon_junctions = step(:affected_exon_junctions).load.clean_annotations
+
+    (with_damaged_isoforms + truncated + affected_exon_junctions).uniq
   end
 
-  def mutations_at_genes(genes)
-    genes = genes.to("Ensembl Gene ID").compact
-    s2g = self.self2genes 
-    subset = s2g.select("Ensembl Gene ID" => genes).keys.collect{|e| e.dup}
-    GenomicMutation.setup(subset, name + '.mutations_at_genes', organism)
+  %w(all_affected_genes damaged_genes truncated with_damaged_isoforms affected_exon_junctions long_genes recurrent_genes).each do |name|
+    define_method name do |*args|
+      @cache ||= {}
+      @cache[[name, args]] ||= self.job(name, self.jobname).run
+    end
   end
 end
+

data/lib/rbbt/entity/mutated_isoform.rb

@@ -0,0 +1,179 @@
+require 'rbbt/entity'
+require 'rbbt/workflow'
+require 'rbbt/sources/organism'
+require 'rbbt/mutation/mutation_assessor'
+require 'rbbt/mutation/sift'
+require 'rbbt/entity/protein'
+require 'rbbt/entity/gene'
+require 'nokogiri'
+
+module MutatedIsoform
+  extend Entity
+  self.annotation :organism
+
+  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
+  end
+
+  property :change => :single2array do
+    self.split(":").last
+  end
+
+  property :position => :single2array do
+    if change.match(/[^\d](\d+)[^\d]/)
+      $1.to_i
+    else
+      nil
+    end
+  end
+  
+  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
+ 
+  property :marked_svg => :single2array do
+    svg = Open.read(protein.ensembl_protein_image_url)
+    seq_len = protein.sequence_length
+    position = self.position
+
+
+    doc = Nokogiri::XML(svg)
+    width = doc.css('svg').first.attr('width').to_f
+    height = doc.css('svg').first.attr('height').to_f
+    start = doc.css('rect.ac').first.attr('x').to_f
+
+    if width and height and start and seq_len and position
+      offset = (width - start)/seq_len * position + start
+      svg.sub(/<\/svg>/,"<rect x='#{offset}' y='1' width='1' height='#{height}' style='fill:rgb(255,0,0);opacity:0.5;stroke:none;'></svg>")
+    else
+      svg
+    end
+  end
+
+  ASTERISK = "*"[0]
+  CONSECUENCES = %w(UTR SYNONYMOUS NOSTOP MISS-SENSE INDEL FRAMESHIFT NONSENSE)
+  property :consecuence => :single2array do
+    prot, change = self.split(":")
+
+    case
+    when change =~ /UTR/
+      "UTR"
+    when (change[0] == ASTERISK and not change[0] == change[-1])
+      "NOSTOP"
+    when (change[-1] == ASTERISK and not change[0] == change[-1])
+      "NONSENSE"
+    when change =~ /Indel/
+      "INDEL"
+    when change =~ /FrameShift/
+      "FRAMESHIFT"
+    when change[0] == change[-1]
+      "SYNONYMOUS"
+    else
+      "MISS-SENSE"
+    end
+  end
+
+  property :truncated => :array2single do
+    @truncated ||= 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
+                       position = isoform_mutation.position
+                       sequence_length = protein2sequence_length[protein]
+
+                       case
+                       when (sequence_length.nil? or position.nil?)
+                         nil
+                       when position < sequence_length.to_f * 0.7
+                         true
+                       else
+                         false
+                       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
+  end
+
+  property :sift_scores => :array2single do
+    @sift_scores ||= begin
+                       missense = self.select{|iso_mut| iso_mut.consecuence == "MISS-SENSE"}
+
+                       values = SIFT.chunked_predict(missense).values_at(*self).collect{|v|
+                         v.nil? ? nil : v["Prediction"]
+                       }
+
+                       range = {nil => nil,
+                         ""  => nil,
+                         "TOLERATED" => 0,
+                         "*DAMAGING" => 1,
+                         "DAMAGING" => 1}
+
+                       range.values_at *values
+                     end
+  end
+
+  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
+  end
+
+end

data/lib/rbbt/entity/pmid.rb

@@ -0,0 +1,19 @@
+require 'rbbt/entity'
+require 'rbbt/sources/pubmed'
+
+module PMID
+  extend Entity
+
+  self.format = "PMID"
+
+  property :title => :array2single do
+    @title ||= begin
+                 PubMed.get_article(self).values_at(*self).collect{|article| article.nil? ? nil : article.title}
+               end
+  end
+
+  property :pubmed_url => :single2array do
+    "<a class='pmid' href='http://www.ncbi.nlm.nih.gov/pubmed/#{self}'>#{ self }</a>"
+  end
+end
+

data/lib/rbbt/entity/protein.rb

@@ -3,6 +3,7 @@ require 'rbbt/workflow'
 require 'rbbt/sources/organism'
 require 'rbbt/statistics/hypergeometric'
 require 'rbbt/network/paths'
+require 'rbbt/entity/gene'
 
 Workflow.require_workflow "Translation"
 
@@ -14,17 +15,48 @@ module Protein
   self.annotation :format
   self.annotation :organism
 
-  def gene
-    Gene.setup(to("Ensembl Protein ID"), "Ensembl Protein ID", organism)
+  self.format = "Ensembl Protein ID"
+
+  def ensembl
+    to "Ensembl Protein ID"
+  end
+
+  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=#{ensembl};_rmd=d2a8;export=svg"
   end
 
-  def to(new_format)
+  property :to! => :array2single do |new_format|
     return self if format == new_format
-    if Array === self
-      Protein.setup(Translation.job(:translate_protein, "", :organism => organism, :proteins => self, :format => new_format).exec, new_format, organism)
-    else
-      Protein.setup(Translation.job(:translate_protein, "", :organism => organism, :proteins => [self], :format => new_format).exec.first, new_format, organism)
-    end
+    Protein.setup(Translation.job(:translate_protein, "", :organism => organism, :proteins => self, :format => new_format).exec, new_format, organism)
+  end
+
+  property :to => :array2single do |new_format|
+    return self if format == new_format
+    to!(new_format).collect!{|v| v.nil? ? nil : v.first}
+  end
+
+  property :gene do
+    Gene.setup(to("Ensembl Protein ID").clean_annotations, "Ensembl Protein ID", organism)
+  end
+
+  property :pfam => :array2single do
+    index = Organism.gene_pfam(organism).tsv :flat, :persist => true
+    index.unnamed = true
+    pfam = index.values_at(*self).flatten
+    Pfam.setup pfam
+  end
+
+  property :sequence => :array2single do
+    @protein_sequence ||= begin
+                            protein_sequence = Organism.protein_sequence(organism).tsv :persist => true
+                            protein_sequence.unnamed = true
+                            protein_sequence.values_at(*self.ensembl)
+                          end
+  end
+
+  property :sequence_length => :array2single do
+    sequence.collect{|seq| seq.nil? ? nil : seq.length}
   end
 end
 

data/test/rbbt/entity/test_gene.rb

@@ -6,9 +6,49 @@ require 'test/unit'
 require 'rbbt/entity/gene'
 
 class TestGene < Test::Unit::TestCase
+  CDK5 = Gene.setup("CDK5", "Associated Gene Name", "Hsa")
+  TP53 = Gene.setup("TP53", "Associated Gene Name", "Hsa")
+  TWO = Gene.setup(["CDK5", "TP53"], "Associated Gene Name", "Hsa")
+
   def test_to
     assert_equal "1020", Gene.setup("CDK5", "Associated Gene Name", "Hsa").to("Entrez Gene ID")
   end
+
+  def test_long_name
+    assert_equal "cyclin-dependent kinase 5", Gene.setup("CDK5", "Associated Gene Name", "Hsa").long_name
+    assert_equal ["cyclin-dependent kinase 5"], Gene.setup(["CDK5"], "Associated Gene Name", "Hsa").long_name
+
+    assert_match /tumor/, Gene.setup("TP53", "Associated Gene Name", "Hsa").description
+  end
+
+  def test_transcripts
+    assert CDK5.transcripts.length > 1
+    assert_equal "Hsa", CDK5.transcripts.organism
+    assert_equal "Hsa", CDK5.make_list.transcripts.first.organism
+    assert_equal "Hsa", CDK5.transcripts.make_list.organism
+  end
+
+  def test_proteins
+    assert CDK5.proteins.length > 1
+  end
+
+  def test_max_protein_length
+    assert CDK5.max_protein_length > 200
+    assert Array === TWO.max_protein_length
+    assert TWO.max_protein_length.first > 200
+  end
+
+  def test_max_transcript_length
+    assert CDK5.max_transcript_length > 200
+    assert Array === TWO.max_transcript_length
+    assert TWO.max_transcript_length.first > 200
+  end
+
+  def test_range
+    assert Range === CDK5.range
+    assert Range === CDK5.make_list.range.first
+  end
+
 end
 
 

data/test/rbbt/entity/test_genomic_mutation.rb

@@ -0,0 +1,38 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+
+require 'test/unit'
+require 'rbbt/util/tmpfile'
+require 'test/unit'
+require 'rbbt/entity/genomic_mutation'
+
+class TestGenomicMutation < Test::Unit::TestCase
+  MUTATION = GenomicMutation.setup("10:124745844:A:158", "Test", "Hsa/jun2011")
+  SPLICING = GenomicMutation.setup("18:14787040:A", "Test", "Hsa/jun2011")
+  GENOTYPE = GenomicMutation.setup(Rbbt.data.genotype.list, "Test", "Hsa/jun2011")
+
+  def test_genes
+    assert GENOTYPE.genes.flatten.to("Associated Gene Name").include? "PSTK"
+  end
+
+  def test_consolidate
+    assert GENOTYPE.genes.consolidate.to("Associated Gene Name").include? "PSTK"
+  end
+
+  def test_mutated_isoforms
+    assert MUTATION.mutated_isoforms.length > 1
+    assert ["PSTK"], MUTATION.mutated_isoforms.protein.gene.to("Associated Gene Name").uniq
+  end
+
+  def test_exon_junction
+    assert(!(MUTATION.in_exon_junction?))
+    assert SPLICING.in_exon_junction?
+  end
+
+  def test_over_gene
+    assert MUTATION.over_gene? Gene.setup("PSTK", "Associated Gene Name", "Hsa/jun2011").ensembl
+    assert(!(SPLICING.over_gene? Gene.setup("PSTK", "Associated Gene Name", "Hsa/jun2011").ensembl))
+  end
+
+end
+
+

data/test/rbbt/entity/test_mutated_isoform.rb

@@ -0,0 +1,37 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+
+require 'test/unit'
+require 'rbbt/util/tmpfile'
+require 'test/unit'
+require 'rbbt/entity/mutated_isoform'
+
+class TestMutatedIsoform < Test::Unit::TestCase
+  MUTATION = MutatedIsoform.setup("ENSP00000275493:G719A", "Hsa/jun2011")
+
+  def test_protein
+    assert_equal "EGFR", MUTATION.protein.gene.to("Associated Gene Name")
+  end
+
+  def test_truncated
+
+    protein = Protein.setup(Gene.setup("CDK5", "Associated Gene Name", "Hsa/jun2011").to("Ensembl Protein ID"), "Ensembl Protein ID", "Hsa/jun2011")
+
+    change_position = (protein.sequence_length.to_f * 0.5).to_i
+    wildtype = protein.sequence[(change_position..change_position)]
+    mutation = "*"
+    new_mutation = wildtype << change_position.to_s << mutation
+    mutation = MutatedIsoform.setup([protein, new_mutation] * ":", "Hsa/jun2011")
+    assert mutation.truncated
+
+
+    change_position = (protein.sequence_length.to_f * 0.9).to_i
+    wildtype = protein.sequence[(change_position..change_position)]
+    mutation = "*"
+    new_mutation = wildtype << change_position.to_s << mutation
+    mutation = MutatedIsoform.setup([protein, new_mutation] * ":", "Hsa/jun2011")
+    assert !mutation.truncated
+  end
+
+end
+
+

data/test/rbbt/entity/test_protein.rb

@@ -0,0 +1,27 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+
+require 'test/unit'
+require 'rbbt/util/tmpfile'
+require 'test/unit'
+require 'rbbt/entity/protein'
+
+class TestProtein < Test::Unit::TestCase
+  PROTEIN = Protein.setup("ENSP00000275493", "Hsa/jun2011")
+  PROTEIN_ARRAY = Protein.setup(["ENSP00000275493"], "Hsa/jun2011")
+
+  def test_clean_annotations
+    assert Protein === PROTEIN
+    assert(!(Protein === PROTEIN.clean_annotations))
+    assert Gene === PROTEIN.gene
+    assert(!(Protein === PROTEIN.gene))
+    assert(PROTEIN_ARRAY.respond_to? :annotated_array_clean_each)
+    assert(!(PROTEIN_ARRAY.clean_annotations.respond_to? :annotated_array_clean_each))
+  end
+
+  def test_gene
+    assert_equal "EGFR", PROTEIN.gene.to("Associated Gene Name")
+  end
+
+end
+
+

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rbbt-entities
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 23
   prerelease: 
   segments: 
-  - 0
   - 1
   - 0
-  version: 0.1.0
+  - 0
+  version: 1.0.0
 platform: ruby
 authors: 
 - Miguel Vazquez
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-10-03 00:00:00 +02:00
+date: 2011-11-17 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -71,12 +71,20 @@ extra_rdoc_files:
 files: 
 - LICENSE
 - lib/rbbt/entity.rb
+- lib/rbbt/entity/cnv.rb
 - lib/rbbt/entity/gene.rb
+- lib/rbbt/entity/genomic_mutation.rb
 - lib/rbbt/entity/genotype.rb
 - lib/rbbt/entity/misc.rb
+- lib/rbbt/entity/mutated_isoform.rb
+- lib/rbbt/entity/pmid.rb
 - lib/rbbt/entity/protein.rb
 - test/test_helper.rb
 - test/rbbt/entity/test_gene.rb
+- test/rbbt/entity/test_genomic_mutation.rb
+- test/rbbt/entity/test_mutated_isoform.rb
+- test/rbbt/entity/test_protein.rb
+- test/rbbt/test_entity.rb
 has_rdoc: true
 homepage: http://github.com/mikisvaz/rbbt-util
 licenses: []
@@ -114,3 +122,7 @@ summary: Entities for the Ruby Bioinformatics Toolkit (rbbt)
 test_files: 
 - test/test_helper.rb
 - test/rbbt/entity/test_gene.rb
+- test/rbbt/entity/test_genomic_mutation.rb
+- test/rbbt/entity/test_mutated_isoform.rb
+- test/rbbt/entity/test_protein.rb
+- test/rbbt/test_entity.rb