rbbt-study 0.2.30 → 0.2.31

data/lib/rbbt/entity/study/expression.rb

@@ -1,24 +0,0 @@
-module StudyWorkflow
-  helper :organism do
-    study.metadata[:organism]
-  end
-
-  task :matrix => :tsv do
-    matrix = study.matrix("gene_expression", "Ensembl Gene ID", organism)
-    matrix.matrix_file(path)
-    nil
-  end
-
-  task :expression_barcode => :tsv do |*args|
-    factor = args.first || 2
-    matrix = study.matrix("gene_expression", "Ensembl Gene ID", organism)
-    matrix.barcode(path, factor)
-    nil
-  end
-end
-
-module Study
-  def has_expression?
-    dir.matrices["gene_expression"].exists?
-  end
-end

data/lib/rbbt/entity/study/features.rb

@@ -1,17 +0,0 @@
-dep :mutated_genes_per_sample
-input :list, :array, "Gene list in Ensembl Gene ID"
-task :gene_features => :tsv do |list|
-  mutated_genes_per_sample = step(:mutated_genes_per_sample).load
-
-
-  samples = study.cohort.fields
-  fields = list.name.collect{|n| n + "_mut"}
-  table = TSV.setup({}, :key_field => "Sample", :fields => fields)
-
-  samples.each do |sample|
-    affected_genes = mutated_genes_per_sample[sample] || []
-    table[sample] = list.collect{|gene| affected_genes.include?(gene)? 1 : 0}
-  end
-
-  table
-end

data/lib/rbbt/entity/study/genes.rb

@@ -1,104 +0,0 @@
-# NON UNIQ
-returns "Ensembl Gene ID"
-task :affected_genes => :annotations do
-  Gene.setup(study.cohort.collect{|genotype| genotype.genes.compact}.flatten, "Ensembl Gene ID", organism)
-end
-
-# NON UNIQ
-dep :relevant_mutations
-returns "Ensembl Gene ID"
-task :relevant_genes => :annotations do
-  relevant_mutations = step(:relevant_mutations).load
-  genes = relevant_mutations.collect{|mutation|
-    splicing = mutation.in_exon_junction? ? mutation.transcripts_with_affected_splicing.gene : []
-    protein = (mis = mutation.mutated_isoforms).nil? ? [] : mis.protein.gene.compact.uniq
-    (splicing + protein).uniq
-  }.compact.flatten
-  Gene.setup(genes, "Ensembl Gene ID", organism)
-end
-
-# NON UNIQ
-dep :relevant_mutations
-returns "Ensembl Gene ID"
-input :methods, :array, "Damage prediction methods", [:sift, :mutation_assessor]
-input :add_exon_junction, :boolean, "Add exon junction mutations", true
-task :damaged_genes => :annotations do |methods, add_exon_junction|
-  relevant_mutations = step(:relevant_mutations).load
-  all_mis = relevant_mutations.mutated_isoforms.compact.flatten
-  mi_damaged = Misc.process_to_hash(all_mis){|all_mis| all_mis.damaged?(methods) }
-
-  genes = relevant_mutations.collect{|mutation|
-    genes = []
-
-    genes.concat mutation.transcripts_with_affected_splicing.gene if add_exon_junction and mutation.in_exon_junction? and mutation.type != 'none'
-
-    mis = mutation.mutated_isoforms
-    genes.concat mis.select{|mi| mi_damaged[mi]}.protein.gene.compact.uniq unless mis.nil?
-
-    genes.uniq
-  }.compact.flatten
-
-  Gene.setup(genes, "Ensembl Gene ID", organism)
-end
-
-dep :relevant_genes
-task :gene_mutation_count => :yaml do
-  relevant_genes = step(:relevant_genes).load
-  if relevant_genes.any?
-    Misc.counts(relevant_genes.clean_annotations)
-  else
-    {}
-  end
-end
-
-# NON UNIQ
-dep :gene_mutation_count
-input :percentage, :float, "Minimum percentage of samples with the mutation", 0
-returns "Ensembl Gene ID"
-task :recurrent_genes => :annotations do |percentage|
-  gene_mutation_count = step(:gene_mutation_count).load
-  minimum = (study.cohort.length.to_f * percentage.to_f) / 100.0
-
-  genes = gene_mutation_count.select{|gene, count| 
-    
-    count > 1 and count > minimum 
-  
-  }.collect{|gene, count| gene}
-
-  Gene.setup(genes, "Ensembl Gene ID", organism)
-end
-
-dep :damaged_genes
-dep :recurrent_genes
-returns "Ensembl Gene ID"
-task :suspect_genes => :annotations do
-  damaged_genes = step(:damaged_genes).load
-  recurrent_genes = step(:recurrent_genes).load
-
-  Gene.setup(( damaged_genes + recurrent_genes ).flatten.uniq, "Ensembl Gene ID", organism)
-end
-
-dep :relevant_mutations
-dep :recurrent_genes
-task :mutations_over_recurrent_genes => :annotations do
-  relevant_mutations = step(:relevant_mutations).load
-  recurrent_genes = step(:recurrent_genes).load
-
-  relevant_mutations.select{|mutation| mutation.genes and (mutation.genes & recurrent_genes).any?}
-end
-
-dep :relevant_mutations
-dep :suspect_genes
-task :mutations_over_suspect_genes => :annotations do
-  relevant_mutations = step(:relevant_mutations).load
-  suspect_genes = step(:suspect_genes).load
-
-  relevant_mutations.select{|mutation| mutation.genes and (mutation.genes & suspect_genes).any?}
-end
-
-require 'rbbt/mutation/oncodriveFM'
-task :oncodriveFM => :tsv do
-  tsv = OncodriveFM.process_cohort(study.cohort)
-  tsv.namespace = organism
-  tsv
-end

data/lib/rbbt/entity/study/genotypes.rb

@@ -1,134 +0,0 @@
-require 'rbbt/entity/genotype'
-
-require 'rbbt/entity/study/genotypes/samples'
-require 'rbbt/entity/study/genotypes/mutations'
-require 'rbbt/entity/study/genotypes/genes'
-require 'rbbt/entity/study/genotypes/enrichment'
-require 'rbbt/entity/study/genotypes/knowledge_base'
-
-module StudyWorkflow
-  helper :organism do
-    study.metadata[:organism]
-  end
-
-  #task :binomial_significance => :tsv do
-
-  #  tsv = TSV.setup({}, :key_field => "Ensembl Gene ID", :fields => ["Matches", "Bases", "Frequency", "p.value"], :namespace => organism)
-
-  #  matches = study.knowledge_base.get_index(:mutation_genes).keys
-  #  genes = matches.collect{|m| m.partition("~").last}.uniq
-  #  all_mutations = matches.collect{|m| m.partition("~").first}.uniq
-
-  #  total_bases = Gene.gene_list_exon_bases(genes)
-  #  global_frequency = all_mutations.length.to_f / total_bases
-
-  #  gene2exon_size = Misc.process_to_hash(genes){|genes| genes.collect{|gene| Gene.gene_list_exon_bases([gene]) }}
-
-  #  genes.each do |gene|
-  #    mutations = study.knowledge_base.parents(:mutation_genes, gene).target
-  #    mutations = study.knowledge_base.subset(:sample_mutations, "Genomic Mutation" => mutations, "Sample" => :all).source
-  #    next if mutations.empty?
-  #    matches = mutations.length
-  #    exon_bases = gene2exon_size[gene]
-  #    next if exon_bases == 0
-  #    frequency = matches.to_f / exon_bases
-  #    pvalue = RSRuby.instance.binom_test(matches, exon_bases, global_frequency, 'greater')["p.value"]
-  #    tsv[gene] = [matches, exon_bases, frequency, pvalue]
-  #  end
-
-  #  tsv
-  #end
-
-  task :genotype_overview => :tsv do
-    gene_overview = TSV.setup({}, 
-                          :key_field => "Ensembl Gene ID", 
-                          :fields => ["Samples with gene mutated", "Samples with gene affected", "Samples with gene damaged", "Mutation significance"],
-                          :type => :double
-                         )
-    genotyped_samples = study.samples.select_by(:has_genotype?)
-    all_mutations = study.all_mutations
-    if all_mutations.empty?
-      gene_overview 
-    else
-
-      log :affected_genes, "Computing how genes are affected by mutations"
-      mutation_genes = Misc.process_to_hash(all_mutations){|all_mutations| all_mutations.genes}
-      mutation_affected_genes = Misc.process_to_hash(all_mutations){|all_mutations| all_mutations.affected_genes}
-      if all_mutations.length < 5000
-        log :damaged_genes, "Computing damaged genes"
-        mutation_damaged_genes = Misc.process_to_hash(all_mutations){|all_mutations| all_mutations.damaged_genes}
-      else
-        mutation_damaged_genes = Misc.process_to_hash(all_mutations){|all_mutations| [nil] * all_mutations.length}
-      end
-      log :significance, "Computing mutation significance"
-      mutation_significance = NKIWorkflow.job(:significantly_mutated, study, :study => study, :threshold => 0.1).run
-      log :significance, "Reordering mutation significance file"
-
-      mutation_significance.identifiers = Organism.identifiers(study.organism)
-      mutation_significance = mutation_significance.change_key "Ensembl Gene ID" 
-
-      log :samples, "Gathering affected samples"
-      samples_gene_status = {}
-      genotyped_samples.each do |sample|
-        samples_gene_status[sample] = {}
-
-        mutation_genes.values_at(*sample.mutations).each do |genes|
-          genes.each do |gene|
-            samples_gene_status[sample][gene] ||= [false, false, false]
-            samples_gene_status[sample][gene][0] = true
-          end
-        end
-
-        mutation_affected_genes.values_at(*sample.mutations).each do |genes|
-          genes.each do |gene|
-            samples_gene_status[sample][gene] ||= [false, false, false]
-            samples_gene_status[sample][gene][1] = true
-          end
-        end
-
-        mutation_damaged_genes.values_at(*sample.mutations).each do |genes|
-          next if genes.nil?
-          genes.each do |gene|
-            samples_gene_status[sample][gene] ||= [false, false, false]
-            samples_gene_status[sample][gene][2] = true
-          end 
-        end
-      end
-
-      log :compiling, "Compiling result"
-      mutation_genes.values.compact.flatten.uniq.each do |gene|
-        gene_overview[gene] = []
-        gene_overview[gene] << samples_gene_status.select{|sample, gene_status| gene_status.include? gene and gene_status[gene][0]}.collect{|sample, gene_status| sample}
-        gene_overview[gene] << samples_gene_status.select{|sample, gene_status| gene_status.include? gene and gene_status[gene][1]}.collect{|sample, gene_status| sample} 
-        gene_overview[gene] << samples_gene_status.select{|sample, gene_status| gene_status.include? gene and gene_status[gene][2]}.collect{|sample, gene_status| sample} 
-        gene_overview[gene] << [mutation_significance.include?(gene) ? mutation_significance[gene]["p.value"] : "> 0.1"]
-      end
-
-      gene_overview
-    end
-  end
-end
-
-module Study
-  def has_genotypes?
-    dir.genotypes.exists?
-  end
-
-  attr_accessor :watson
-  def watson
-    @watson  = metadata[:watson] if @watson.nil?
-    @watson
-  end
-
-  def genotype_files
-    dir.genotypes.glob("*")
-  end
-
-  def cohort
-    @cohort ||= genotype_files.collect do |f| 
-      name = File.basename(f)
-      genomic_mutations = Open.read(f).split("\n").sort
-      GenomicMutation.setup(genomic_mutations, name, organism, watson)
-    end.tap{|cohort| cohort.extend Genotype::Cohort}
-  end
-end

data/lib/rbbt/entity/study/genotypes/enrichment.rb

@@ -1,56 +0,0 @@
-require 'rbbt/workflow'
-
-Workflow.require_workflow "MutationEnrichment"
-module StudyWorkflow
-
-  #{{{ SAMPLE ENRICHMENT
-  input :database, :string
-  input :mutation_subset, :select, "Mutation subset to use", :relevant_mutations
-  input :baseline, :select, "Type of baseline to use", :pathway_base_counts, :select_options => [:pathway_base_counts, :pathway_gene_counts]
-  input :permutations, :integer, "Number of permutations in test", 10000
-  input :fdr, :boolean, "BH FDR corrections", true
-  input :masked_genes, :array, "Ensembl Gene ID list of genes to mask", []
-  task :sample_pathway_enrichment => :tsv do |database,mutation_subset,baseline,permutations,fdr,masked_genes|
-
-    mutations = study.send(mutation_subset)
-
-    mutation_tsv = TSV.setup({}, :key_field => "Genomic Mutation", :fields => ["Sample"], :type => :flat)
-
-    study.cohort.each do |genotype|
-      sample = genotype.jobname
-      genotype.each do |mutation|
-        next unless mutations.include? mutation
-        mutation_tsv[mutation] ||= []
-        mutation_tsv[mutation] << sample
-      end
-    end
-
-    job = MutationEnrichment.job(:sample_pathway_enrichment, study, 
-                                 :mutations => mutation_tsv, :database => database, :baseline => baseline, :fdr => fdr, 
-                                 :masked_genes => masked_genes, :organism => study.organism, :permutations => permutations)
-
-    res = job.run
-    set_info :total_covered, job.info[:total_covered]
-    set_info :covered_mutations, job.info[:covered_mutations]
-    res
-  end
-
-  #{{{ METAGENOTYPE ENRICHMENT
-  input :database, :string
-  input :mutation_subset, :select, "Mutation subset to use", :relevant_mutations
-  input :baseline, :select, "Type of baseline to use", :pathway_base_counts, :select_options => [:pathway_base_counts, :pathway_gene_counts]
-  input :fdr, :boolean, "BH FDR corrections", true
-  input :masked_genes, :array, "Ensembl Gene ID list of genes to mask", []
-  task :mutation_pathway_enrichment => :tsv do |database,mutation_subset,baseline,fdr,masked_genes,organism|
-
-    mutations = study.send(mutation_subset)
-
-    job = MutationEnrichment.job(:mutation_pathway_enrichment, study, 
-                                 :mutations => mutations, :database => database, :baseline => baseline, :fdr => fdr, 
-                                 :masked_genes => masked_genes, :organism => study.organism)
-    res = job.run
-    set_info :total_covered, job.info[:total_covered]
-    set_info :covered_mutations, job.info[:covered_mutations]
-    res
-  end
-end

data/lib/rbbt/entity/study/genotypes/genes.rb

@@ -1,104 +0,0 @@
-module Study
-  property :genes_with_overlapping_mutations => :single do
-    mutations = cohort.metagenotype
-    mutations.genes.compact.flatten.uniq
-  end
-
-  property :altered_isoforms => :single do
-    mutated_isoforms = cohort.metagenotype.subset(relevant_mutations).mutated_isoforms.compact.flatten.uniq
-    return [] if mutated_isoforms.empty?
-    mutated_isoforms.select_by(:consequence){|c| c != "SYNONYMOUS"}
-  end
-
-  property :genes_with_altered_isoform_sequence => :single do
-    altered_isoforms = self.altered_isoforms
-    return [] if altered_isoforms.empty?
-    altered_isoforms.transcript.compact.gene.uniq
-  end
-
-  property :damaged_isoforms => :single do |*args|
-    altered_isoforms = self.altered_isoforms
-    return [] if altered_isoforms.empty?
-    altered_isoforms.select_by(:damaged?, *args)
-  end
-
-  property :genes_with_damaged_isoforms => :single do |*args|
-    damaged_isoforms = damaged_isoforms(*args)
-    return [] if damaged_isoforms.empty?
-    damaged_isoforms.transcript.gene.uniq
-  end
-
-  property :genes_with_affected_splicing_sites => :single do
-    cohort.metagenotype.subset(relevant_mutations).transcripts_with_affected_splicing.compact.flatten.uniq.gene.compact.uniq
-  end
-
-  property :affected_genes => :single do
-    Gene.setup(genes_with_altered_isoform_sequence + genes_with_affected_splicing_sites, "Ensembl Gene ID", organism).uniq
-  end
-
-  property :damaged_genes => :single do |*args|
-    Gene.setup((genes_with_damaged_isoforms(*args) + genes_with_affected_splicing_sites).uniq, "Ensembl Gene ID", organism)
-  end
-
- property :samples_with_gene_damaged => :single do
-    damaging_mutations= self.damaging_mutations
-
-    samples_with_gene_damaged = {}
-    cohort.each do |genotype|
-      genotype.each do |mutation|
-        next unless damaging_mutations.include? mutation
-        genes = []
-        mis = mutation.mutated_isoforms
-        genes.concat mis.select_by(:damaged?).transcript.gene unless mis.nil? or mis.empty?
-        genes.concat mutation.transcripts_with_affected_splicing.gene
-        genes.uniq.each{|gene| samples_with_gene_damaged[gene] ||= []; samples_with_gene_damaged[gene] << genotype.jobname}
-      end
-    end
-    samples_with_gene_damaged
-  end
-
-  property :samples_with_gene_affected => :single do
-    relevant_mutations = self.relevant_mutations
-
-    samples_with_gene_affected = {}
-    cohort.each do |genotype|
-      genotype.each do |mutation|
-        next if mutation.nil?
-        next unless relevant_mutations.include? mutation
-        genes = []
-        mis = mutation.mutated_isoforms
-        genes.concat mis.select_by(:non_synonymous).transcript.gene unless mis.nil? or mis.empty?
-        genes.concat mutation.transcripts_with_affected_splicing.gene
-        genes.uniq.each{|gene| samples_with_gene_affected[gene] ||= []; samples_with_gene_affected[gene] << genotype.jobname}
-      end
-    end
-    samples_with_gene_affected
-  end
-
-  property :gene_sample_matrix => :single do
-    genotyped_samples = samples.select{|s| s.has_genotype?}.sort.uniq
-
-    tsv = TSV.setup({}, :key_field => "Ensembl Gene ID", :namespace => organism, :type => :list, :fields => genotyped_samples)
-
-    num_samples = genotyped_samples.length
-    genotyped_samples.each_with_index do |sample,i|
-      affected_genes = sample.affected_genes
-      next if affected_genes.empty?
-      affected_genes.clean_annotations.each do |gene|
-        tsv[gene] ||= ["FALSE"] * num_samples
-        tsv[gene][i] = "TRUE"
-      end
-    end
-
-    tsv.fields = genotyped_samples
-
-    tsv
-  end
-
-  property :recurrent_genes => :single do |*args|
-    min = args.first 
-    min = 2 if min.nil?
-
-    Gene.setup(samples_with_gene_affected.select{|gene, samples| samples.length >= min }.collect{|gene,samples| gene}, "Ensembl Gene ID", organism)
-  end
-end

data/lib/rbbt/entity/study/genotypes/knowledge_base.rb

@@ -1,81 +0,0 @@
-require 'rbbt/workflow'
-Workflow.require_workflow "Genomics"
-require 'rbbt/entity/gene'
-require 'rbbt/entity/genomic_mutation'
-
-module Study
-
-  self.study_registry[:mutation_genes] = Proc.new{|study,database|
-    tsv = TSV.setup({}, :key_field => "Genomic Mutation", :fields => ["Ensembl Gene ID"], :type => :flat, :namespace => study.organism)
-    study.cohort.metagenotype.uniq.each do |mutation|
-      tsv[mutation] = mutation.genes
-    end
-    tsv
-  }
-
-  self.study_registry[:mutation_affected_genes] = Proc.new{|study,database|
-    tsv = TSV.setup({}, :key_field => "Genomic Mutation", :fields => ["Ensembl Gene ID"], :type => :flat, :namespace => study.organism)
-    study.cohort.metagenotype.uniq.each do |mutation|
-      tsv[mutation] = mutation.affected_genes
-    end
-    tsv
-  }
-
-  self.study_registry[:mutation_damaged_genes] = Proc.new{|study,database|
-    tsv = TSV.setup({}, :key_field => "Genomic Mutation", :fields => ["Ensembl Gene ID"], :type => :flat, :namespace => study.organism)
-    study.cohort.metagenotype.uniq.each do |mutation|
-      tsv[mutation] = mutation.damaged_genes
-    end
-    tsv
-  }
-
-  self.study_registry[:sample_mutations] = Proc.new{|study,database|
-    tsv = TSV.setup({}, :key_field => "Sample", :fields => ["Genomic Mutation"], :type => :flat, :namespace => study.organism)
-
-    study.samples.select_by(:has_genotype?).each do |sample|
-      tsv[sample] = sample.mutations
-    end
-
-    tsv
-  }
-
-  self.study_registry[:sample_genes] = Proc.new{|study,database|
-    tsv = TSV.setup({}, :key_field => "Sample", :fields => ["Ensembl Gene ID", "Genomic Mutation", "Affected isoform", "Damaged isoform", "Exon Junction"], :type => :double, :namespace => study.organism)
-
-    sample_mutations = study.knowledge_base.get_database(:sample_mutations, :source => "Sample")
-    all_mutations = study.all_mutations
-    mutations2mutated_isoforms = Misc.process_to_hash(all_mutations){|mutations| mutations.any? ? mutations.mutated_isoforms : [] }
-    mutations2exon_junction = Misc.process_to_hash(all_mutations){|mutations| mutations.any? ? mutations.in_exon_junction? : [] }
-    mi2damaged = Misc.process_to_hash(MutatedIsoform.setup(mutations2mutated_isoforms.values.flatten.compact.uniq, study.organism)){|mis| mis.any? ? mis.damaged? : [] }
-    #mi2damaged = Misc.process_to_hash(MutatedIsoform.setup(mutations2mutated_isoforms.values.flatten.compact.uniq, study.organism)){|mis| [false] * mis.length }
-    mi2consequence = Misc.process_to_hash(MutatedIsoform.setup(mutations2mutated_isoforms.values.flatten.compact.uniq, study.organism)){|mis| mis.any? ? mis.consequence : [] }
-
-    gene_mutations = study.knowledge_base.get_database(:mutation_genes, :source => "Ensembl Gene ID")
-    gene_mutations.unnamed = true
-    gene_mutations.entity_options["Genomic Mutation"] = {:watson => study.watson, :organism => study.organism}
-    study.samples.select_by(:has_genotype?).each do |sample|
-      values = sample.affected_genes.collect do |gene|
-        mutations = gene_mutations[gene] & (sample_mutations[sample] || [])
-
-        if mutations and mutations.any?
-          GenomicMutation.setup(mutations, "Mutations in #{ sample } over #{ gene }", study.organism, study.watson)
-          junction = mutations.select{|mutation| mutations2exon_junction[mutation] }.any?
-
-          mis = Annotated.flatten mutations2mutated_isoforms.values_at(*mutations).compact
-
-          affected = (mis.any? and mis.select{|mi| c = mi2consequence[mi]; ! %w(UTR SYNONYMOUS).include? c}.any?) 
-          damaged = (mis.any? and mis.select{|mi| mi2damaged[mi]  }.any?) 
-
-          [gene, mutations * ";;", affected, damaged, junction]
-        else
-          [gene, "", false, false, false]
-        end
-      end
-
-      tsv[sample] = Misc.zip_fields values
-    end
-
-    tsv
-  }
-
-end