DomFun 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 87063a5c0ddf9a988af77b9aaa73e2c7c676f2ad
+  data.tar.gz: 725fcefa7c7f464526410e1dcc7f50f6a19adf8f
+SHA512:
+  metadata.gz: 13b5059cf7978c2c8fe8583da5118e46725287f5d90658e7f2574ded9eebf8988d61203fe8c576371ded87f93c64d5ef7de18523c1db72ea0180dde8b9f5b881
+  data.tar.gz: 47a817f6bdffa4efce7624199125afa94ea30d4cdc8e0b2d13f48dd5c6cf25af4e0af0c344988ea3f0ae14a8f8d043168c266d8c72f303267ca45344e315d9aa

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.4.1
+before_install: gem install bundler -v 2.0.1

data/DomFun.gemspec

@@ -0,0 +1,44 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "DomFun/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "DomFun"
+  spec.version       = DomFun::VERSION
+  spec.authors       = ["Elena Rojano, Pedro Seoane"]
+  spec.email         = ["elenarojano@uma.es, seoanezonjic@hotmail.com"]
+
+  spec.summary       = %q{Tool to predict protein functions based on domains-FunSys associations.}
+  spec.description   = %q{From associations calculated between protein domains and functional systems (FunSys), DomFun can predict the functions of proteins looking up domains and the FunSys that have been associated with. The system is validated using data from CAFA.}
+  spec.homepage      = "https://github.com/ElenaRojano/DomFun"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  # if spec.respond_to?(:metadata)
+  #   spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+
+  #   spec.metadata["homepage_uri"] = spec.homepage
+  #   spec.metadata["source_code_uri"] = "TODO: Put your gem's public repo URL here."
+  #   spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+  # else
+  #   raise "RubyGems 2.0 or newer is required to protect against " \
+  #     "public gem pushes."
+  # end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+
+  spec.add_dependency "NetAnalyzer", "~> 0.1.5"
+end

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in DomFun.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 elenarojano
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,39 @@
+# DomFun
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/DomFun`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'DomFun'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install DomFun
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/DomFun.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/add_protein_functional_families.rb

@@ -0,0 +1,133 @@
+#! /usr/bin/env ruby
+##########################
+# Rojano E. & Seoane P., June 2019
+# Generate tripartite networks with domains-proteins-FunSys data
+# Protein IDs and FunSys (GO-MF, KEGG and Reactome) from UniProtKB.
+# Protein domains (Superfamilies and FunFams) from CATH.
+##########################
+
+REPORT_FOLDER=File.expand_path(File.join(File.dirname(__FILE__), '..', 'templates'))
+ROOT_PATH = File.dirname(__FILE__)
+$: << File.expand_path(File.join(ROOT_PATH, '..', 'lib', 'DomFun'))
+require 'generalMethods.rb'
+require 'csv'
+require 'optparse'
+
+##########################
+#METHODS
+##########################
+def build_tripartite_networks(nomenclature_annotations, cath_data, path, protein2gene)
+	records = Hash.new(0)
+  nomenclature_annotations.each do |nomenclature, protein_annotations|
+		annots = []
+		datas = []
+		protein_annotations.each do |protID, annotations|
+			query_cath_data = cath_data[protID]
+			if !query_cath_data.nil?
+				#gene_ID = protein2gene[protID] unless protein2gene[protID].nil?
+        
+				#gene_ID = protID if gene_ID.nil?
+				annotations.each do |annotation|
+          #annots << [annotation, gene_ID]
+					annots << [annotation, protID]
+				end
+				query_cath_data.each do |data|
+          #datas << [data, gene_ID]
+					datas << [data, protID]
+				end
+			end
+		end
+		records[nomenclature] += annots.map{|pair| pair.last}.uniq.length
+		File.open(File.join(path, "network_#{nomenclature}"), 'w') do |f|
+			annots.uniq.each do |pair|
+				f.puts pair.join("\t")
+			end
+			datas.uniq.each do |pair|
+				f.puts pair.join("\t")
+			end
+		end
+	end
+	return records
+end
+
+##########################
+#OPT-PARSER
+##########################
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: #{__FILE__} [options]"
+
+  options[:input_annotations] = nil
+  opts.on("-a", "--input_annotations PATH", "Input file with gene annotations") do |data|
+    options[:input_annotations] = data
+  end
+
+  options[:calculate_proteins_by_domain] = false
+  opts.on("-c", "--calculate_proteins_by_domain", "Calculate the number of proteins that a domain has") do
+    options[:calculate_proteins_by_domain] = true
+  end
+
+  options[:input_domains] = nil
+  opts.on("-d", "--input_domains PATH", "Input file with protein domains") do |data|
+    options[:input_domains] = data
+  end
+
+  options[:search_domain] = true
+  opts.on("-f", "--search_domain", "Search full protein domains. If false, search funfams") do
+    options[:search_domain] = false
+  end
+
+  options[:annotation_types] = %w[ kegg reactome go]
+  opts.on("-p", "--annotation_types STRING", "List of annotation types separated by commas") do |data|
+    options[:annotation_types] = data.split(",")
+  end
+
+  options[:output_stats] = 'uniprot_stats.txt'
+  opts.on("-s", "--output_stats PATH", "Output file with UniProt stats") do |data|
+    options[:output_stats] = data
+  end
+
+  options[:category_type] = 'funfamID'
+  opts.on("-t", "--category_type STRING", "Input category of domains. Options: funfamID, superfamilyID") do |data|
+    options[:category_type] = data
+  end  
+
+  options[:unnanotated_proteins] = 'unnanotated_proteins_list.txt'
+  opts.on("-u", "--unnanotated_proteins PATH", "Output file with unnanotated proteins list") do |data|
+    options[:unnanotated_proteins] = data
+  end
+
+  opts.on_tail("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+
+end.parse!
+
+##########################
+#MAIN
+##########################
+
+puts "Loading data..."
+cath_data, protein2gene, gene2proteins, cath_proteins_number = load_cath_data(options[:input_domains], options[:category_type])
+nomenclature_annotations, number_of_proteins, proteins_without_annotations = load_proteins_file(options[:input_annotations], options[:annotation_types])
+networks_path = nil
+if options[:category_type] == 'funfamID'
+	networks_path = 'networks/funfam_networks'
+else
+	networks_path = 'networks/superfamily_networks'
+end
+puts "Generating tripartite networks. This can take a while, please wait."
+protein_stats = build_tripartite_networks(nomenclature_annotations, cath_data, networks_path, protein2gene)
+handler = File.open(options[:output_stats], 'w')
+protein_stats.each do |annotation_type, number_of_proteins|
+	handler.puts "#{annotation_type}\t#{number_of_proteins}"
+end
+handler.puts "Total of Uniprot proteins\t#{number_of_proteins}"
+handler.puts "Total of Uniprot proteins without annotations\t#{proteins_without_annotations.length}"
+handler.puts "Total of CATH proteins\t#{cath_proteins_number}"
+handler = File.open(options[:unnanotated_proteins], 'w')
+proteins_without_annotations.each do |unnanotated_prot|
+	handler.puts unnanotated_prot
+end
+handler.close

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "DomFun"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/domains_to_function_predictor.rb

@@ -0,0 +1,287 @@
+#! /usr/bin/env ruby
+##########################
+# Rojano E. & Seoane P., June 2019
+# Domain to functional annotation predictor
+# Based on domain-annotation association, this predictor can add functions to a group of domains of a protein
+# It predict the most putative functions associated to a protein based on their domains.
+# Protein IDs and FunSys (GO-MF, KEGG and Reactome) from UniProtKB.
+# Protein domains (Superfamilies and FunFams) from CATH.
+##########################
+
+REPORT_FOLDER=File.expand_path(File.join(File.dirname(__FILE__), '..', 'templates'))
+ROOT_PATH = File.dirname(__FILE__)
+$: << File.expand_path(File.join(ROOT_PATH, '..', 'lib', 'DomFun'))
+require 'generalMethods.rb'
+require 'csv'
+require 'optparse'
+require "statistics2"
+require "terminal-table"
+require 'report_html'
+
+
+##########################
+#METHODS
+##########################
+
+def get_protein_domains(cath_data, protein)
+  domains_to_predict = nil
+  unless cath_data[protein].nil?
+    domains_to_predict = cath_data[protein].uniq
+  end
+  return domains_to_predict
+end
+
+
+def load_domain_to_pathway_association(associations_file, threshold)
+	domain_to_pathway_associations = {}
+	File.open(associations_file).each do |line|
+		line.chomp!
+		annotation, domain, association_value = line.split("\t")
+    association_value = association_value.to_f
+		next if association_value < threshold
+    query = domain_to_pathway_associations[domain]
+		if query.nil?
+			domain_to_pathway_associations[domain] = [[annotation, association_value]]
+		else
+			query << [annotation, association_value]
+		end
+	end
+	return domain_to_pathway_associations
+end
+
+def load_domains_to_predict(domains_file)
+  domains_to_predict = {}
+  File.open(domains_file).each do |line|
+    line.chomp!
+    protein_id, domains = line.split("\t")
+    domains_to_predict[protein_id] = domains.split(',')
+  end
+  return domains_to_predict
+end
+
+def search4function(domains_to_predict, domain_to_pathway_associations)
+  domain_to_function_and_association_value = {}
+  domains_to_predict.each do |domain|
+    #puts domain
+    associations = domain_to_pathway_associations[domain]
+    if !associations.nil?
+      domain_to_function_and_association_value[domain] = associations
+    end
+  end
+  return domain_to_function_and_association_value
+end
+
+
+def group_by_function(domain_to_function_and_association_value)
+  function_to_domains = {}
+  association_scores = {}
+  domain_to_function_and_association_value.each do |domain, annotations|
+    annotations.each do |annotation_id, association_score|
+      query = function_to_domains[annotation_id]
+      if query.nil?
+        function_to_domains[annotation_id] = [domain]
+      else
+        query << domain
+      end
+      query = association_scores[annotation_id]
+      if query.nil?
+        association_scores[annotation_id] = {domain => association_score}
+      else
+        query[domain] = association_score 
+      end
+    end   
+  end
+  return function_to_domains, association_scores
+end
+
+def generate_domain_annotation_matrix(function_to_domains, association_scores, domains_to_predict, null_value=0)
+  # #method for creating the hpo to region matrix for plotting
+  # #info2predict = hpo list from user
+  # #hpo_associated_regions = [[chr, start, stop, [hpos_list], [weighted_association_scores]]]
+  domain_annotation_matrix = []
+  function_to_domains.each do |function_ID, domains_list|
+    row = []
+    domains_to_predict.each do |user_domain|
+      value = association_scores[function_ID][user_domain]
+      if value.nil?
+        row << null_value
+      else
+        row << value
+      end
+    end
+    domain_annotation_matrix << row
+  end
+  return domain_annotation_matrix
+end
+
+def scoring_funsys(function_to_domains, domain_annotation_matrix, scoring_system, freedom_degree='maxnum', null_value=0, pvalue_threshold)
+  domains_array = function_to_domains.values
+  max_cluster_length = domain_annotation_matrix.map{|x| x.count {|i| i != 0}}.max if freedom_degree == 'maxnum'
+  domain_annotation_matrix.each_with_index do |associations, i|
+    sample_length = nil
+    if freedom_degree == 'maxnum'
+      sample_length = max_cluster_length
+    else
+      abort("Invalid freedom degree calculation method: #{freedom_degree}")
+    end
+    if scoring_system == 'fisher'
+      #hyper must be ln not log10 from net analyzer
+      #https://en.wikipedia.org/wiki/Fisher%27s_method
+      lns = associations.map{|a| Math.log(10 ** -a)} #hyper values come as log10 values
+      sum = lns.inject(0){|s, a| s + a} 
+      combined_pvalue = Statistics2.chi2_x(sample_length *2, -2*sum)
+      domains_array[i] << combined_pvalue
+    elsif scoring_system == 'harmonic'
+      #STDERR.puts associations.inspect
+      lns = associations.map{|a| 10 ** -a}
+      inv = lns.map{|n| 1.fdiv(n)}
+      sum = inv.inject(0){|s,x| s + x}
+      combined_pvalue = associations.length.fdiv(sum)
+      domains_array[i] << combined_pvalue
+    elsif scoring_system == 'stouffer'
+      sum = associations.inject(0){|s,x| s + x}      
+      combined_z_score = sum/Math.sqrt(sample_length)
+      domains_array[i] << combined_z_score
+    elsif scoring_system == 'average'
+      sum = associations.inject(0){|s,x| s + x.abs}.fdiv(associations.length)
+      #STDERR.puts sum.inspect
+      domains_array[i] << sum
+    elsif scoring_system == 'sum'
+      sum = associations.inject(0){|s,x| s + x.abs}
+      domains_array[i] << sum
+    else
+      abort("Invalid integration method: #{scoring_system}")
+    end
+  end
+  if scoring_system == 'fisher' || scoring_system == 'harmonic'
+    function_to_domains.select!{|function, attributes| attributes.last <= pvalue_threshold}
+  else
+    function_to_domains.select!{|function, attributes| attributes.last >= pvalue_threshold}
+  end
+  #STDERR.puts function_to_domains.inspect
+end
+
+
+def report_data(predictions, html_file)
+  container = {:predictions => predictions }
+  template = File.open(File.join(REPORT_FOLDER, 'report_data.erb')).read
+  report = Report_html.new(container, 'Protein domains and FunSys predictions summary')
+  report.build(template)
+  report.write(html_file)
+end
+
+##########################
+#OPT-PARSER
+##########################
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: #{__FILE__} [options]"
+  
+  options[:input_associations] = nil
+  opts.on("-a", "--input_associations PATH", "Domain-function associations") do |data|
+    options[:input_associations] = data
+  end
+
+  options[:domain_category] = "superfamilyID"
+  opts.on("-c", "--domain_category PATH", "Domain category. Please choose one: superfamilyID or funfamID" ) do |data|
+    options[:domain_category] = data
+  end
+
+  options[:protein_domains_file] = nil
+  opts.on("-f", "--protein_domains_file PATH", "Input protein-domains file from CATH") do |data|
+    options[:protein_domains_file] = data
+  end
+
+  options[:integration_method] = 'fisher'
+  opts.on("-i", "--integration_method STRING", "Integration method") do |data|
+    options[:integration_method] = data
+  end
+
+  options[:output_file] = 'predictions_file.txt'
+  opts.on("-o", "--output_file PATH", "Predictions file") do |data|
+    options[:output_file] = data
+  end
+
+  options[:proteins_2predict] = nil
+  opts.on("-p", "--proteins_2predict PATH", "Protein to predict. Please use UniProt IDs" ) do |data|
+    options[:proteins_2predict] = data
+  end
+
+  options[:pvalue_threshold] = 0.05
+  opts.on("-t", "--pvalue_threshold FLOAT", "P-value threshold") do |pvalue_threshold|
+    options[:pvalue_threshold] = pvalue_threshold.to_f
+  end
+
+  options[:association_threshold] = 2
+  opts.on("-T", "--association_threshold FLOAT", "Association value threshold") do |association_threshold|
+    options[:association_threshold] = association_threshold.to_f
+  end
+
+  options[:multiple_proteins] = false
+    opts.on("-u", "--multiple_proteins", "Set if multiple profiles") do
+  options[:multiple_proteins] = true
+  end
+
+  opts.on_tail("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+
+end.parse!
+
+##########################
+#MAIN
+##########################
+
+# 1. Load protein domains classification to get domains from proteins to predict
+cath_data, protein2gene, gene2proteins, cath_proteins_number = load_cath_data(options[:protein_domains_file], options[:domain_category])
+# 2. Load protein(s) to predict
+if File.exist?(options[:proteins_2predict])
+  if !options[:multiple_proteins]
+    options[:proteins_2predict] = [File.open(options[:proteins_2predict]).readlines.map!{|line| line.chomp}]
+  else
+    multiple_proteins = []
+    File.open(options[:proteins_2predict]).each do |line|
+      line.chomp!
+      multiple_proteins << line
+    end
+    options[:proteins_2predict] = multiple_proteins
+  end
+else
+  if !options[:multiple_proteins]
+    options[:proteins_2predict] = [options[:proteins_2predict].split('|')]
+  else
+    options[:proteins_2predict] = options[:proteins_2predict].split('!').map{|profile| profile.split('|')}
+  end
+end
+
+
+# 3. Load domain-FunSys associations
+domain_to_pathways_associations = load_domain_to_pathway_association(options[:input_associations], options[:association_threshold])
+# 4. Prediction
+handler = File.open(options[:output_file], 'w')
+options[:proteins_2predict].each do |protein|
+  domains = get_protein_domains(cath_data, protein)
+  next if domains.nil?
+  null_value = 0
+  domain_function_assocValue = search4function(domains, domain_to_pathways_associations)
+  
+  function_to_domains, association_scores = group_by_function(domain_function_assocValue) 
+  annotation_matrix = generate_domain_annotation_matrix(function_to_domains, association_scores, domains, 0) 
+  
+  scoring_funsys(
+    function_to_domains, 
+    annotation_matrix, 
+    options[:integration_method], 
+    'maxnum', 
+    null_value, 
+    options[:pvalue_threshold]
+    )
+
+    function_to_domains.each do |funsys, domains_data|
+      score = domains_data.pop
+      handler.puts "#{protein}\t#{domains_data.join(',')}\t#{funsys}\t#{score}"
+    end
+end
+handler.close