pets 0.2.3 → 0.2.4

data/bin/evidence_profiler.rb

@@ -1,166 +1,63 @@
 #! /usr/bin/env ruby
 
 ROOT_PATH = File.dirname(__FILE__)
-REPORT_FOLDER = File.expand_path(File.join(ROOT_PATH, '..', 'templates'))
-EXTERNAL_DATA = File.expand_path(File.join(ROOT_PATH, '..', 'external_data'))
-EXTERNAL_CODE = File.expand_path(File.join(ROOT_PATH, '..', 'external_code'))
-HPO_FILE = File.join(EXTERNAL_DATA, 'hp.json')
 $: << File.expand_path(File.join(ROOT_PATH, '..', 'lib', 'pets'))
 
 require 'fileutils'
 require 'optparse'
 require 'report_html'
 require 'semtools'
-require 'generalMethods.rb'
-
-
-class Report_html 
-	def circular_genome(user_options = {}, &block)
-		default_options = {}.merge!(user_options)
-		coordinates = user_options[:genomic_coordinates]
-		html_string = canvasXpress_main(default_options, block) do |options, config, samples, vars, values, object_id, x, z|
-			config['graphType'] = 'Circular'
-			config["arcSegmentsSeparation"] = 3
-        	config["colorScheme"] = "Tableau"
-        	config["colors"] = ["#332288","#6699CC","#88CCEE","#44AA99","#117733","#999933","#DDCC77","#661100","#CC6677","#AA4466","#882255","#AA4499"]
-			config["showIdeogram"] = true
-			chr = []
-			pos = []
-			tags2remove = []
-			vars.each_with_index do |var, i|
-				coord = coordinates[var]
-				if !coord.nil?
-					tag = coord.first.gsub(/[^\dXY]/,'')
-					if tag == 'X' || tag == 'Y' || (tag.to_i > 0 && tag.to_i <= 22)
-						chr << coord.first.gsub(/[^\dXY]/,'')
-						pos << coord.last - 1
-					else
-						tags2remove << i
-					end
-				else
-					tags2remove << i
-				end
-			end
-			tags2remove.reverse_each{|i| ent = vars.delete_at(i); warn("Feature #{ent} has not valid coordinates")} # Remove entities with invalid coordinates
-			z['chr'] = chr
-			z['pos'] = pos
-		end
-		return html_string
-	end
-end
+require 'pets'
 
 #############################################################################################
 ## METHODS
 ############################################################################################
-def load_profiles(file_path, hpo)
-	profiles = {}
-	#count = 0
-	File.open(file_path).each do |line|
-		id, profile = line.chomp.split("\t")
-		hpos = profile.split(',').map{|a| a.to_sym}
-		hpos, rejected_hpos = hpo.check_ids(hpos)
-		if !hpos.empty?
-			hpos = hpo.clean_profile(hpos)
-			profiles[id] = hpos if !hpos.empty?
-		end
-	end
-	return profiles
-end
-
-def load_variants(variant_folder)
-	variants = {}
-	coordinates = {}
-	count = 0
-	all_vars = {}
-	Dir.glob(File.join(variant_folder, '*.tab')).each do |path|
-		profile_id = File.basename(path, '.tab')
-		vars = {}
-		File.open(path).each do |line|
-			fields = line.chomp.split("\t")
-			chr = fields[0]
-			start = fields[1].to_i
-			query = coordinates[chr]
-			if query.nil?
-				coordinates[chr] = [start]
-				count += 1
-				id = "var_#{count}"
-			else
-				if !query.include?(start)
-					query << start
-					count += 1
-					id = "var_#{count}"
-				else
-					id = all_vars.key([chr, start]) 
-				end
-			end
-			vars[id] = [chr, start]
-		end
-		all_vars.merge!(vars)
-		variants[profile_id] = vars
-	end
-	return variants
-end
-
-def load_evidences(evidences_path, hpo)
-	genomic_coordinates = {}
-	coord_files = Dir.glob(File.join(evidences_path, '*.coords'))
-	coord_files.each do |cd_f|
-		entity = File.basename(cd_f, '.coords')
-		coordinates = load_coordinates(cd_f)
-		genomic_coordinates[entity] = coordinates
-	end
-	evidences = {}
-	evidence_files = Dir.glob(File.join(evidences_path, '*_HP.txt'))
-	evidence_files.each do |e_f|
-		pair = File.basename(e_f, '.txt')
-		profiles, id2label = load_evidence_profiles(e_f, hpo)
-		evidences[pair] = {prof: profiles, id2lab: id2label}
-	end
-	return evidences, genomic_coordinates
+def get_evidence_coordinates(entity, genomic_coordinates, candidates_ids)
+	all_coordinates = genomic_coordinates[entity]
+	coords = all_coordinates.select{|id, coordinates| candidates_ids.include?(id.to_sym)}
+	return coords
 end
 
-def load_coordinates(file_path)
-	coordinates = {}
-	header = true
-	File.open(file_path).each do |line|
-		fields = line.chomp.split("\t")
-		if header
-			header = false
-		else
-			entity, chr, strand, start, stop = fields
-			coordinates[entity] = [chr, start.to_i, stop.to_i, strand]
-		end
-	end
-	return coordinates
+def make_report(profile_id, all_candidates, all_genomic_coordinates, similarity_matrixs, evidences, prof_vars, template, output)
+	var_ids, var_coors = format_variants4report(prof_vars)
+	container = {
+		profile_id: profile_id,
+		candidates: all_candidates.each{|c| c[0] = c.first.to_s},
+		genomic_coordinates: all_genomic_coordinates.transform_values{|c| c.first(2) },
+		similarity_matrixs: similarity_matrixs,
+		evidences: evidences,
+		var_ids: var_ids,
+		var_coordinates: var_coors
+	}
+	report = Report_html.new(container, 'Evidence profile report')
+	report.build(template)
+	report.write(File.join(output, profile_id.to_s + '.html'))
 end
 
-def load_evidence_profiles(file_path, hpo)
-	profiles = {}
-	id2label = {}
-	#count = 0
-	File.open(file_path).each do |line|
-		id, label, profile = line.chomp.split("\t")
-		hpos = profile.split(',').map{|a| a.to_sym}
-		hpos, rejected_hpos = hpo.check_ids(hpos)
-		if !hpos.empty?
-			hpos = hpo.clean_profile(hpos)
-			profiles[id] = hpos if !hpos.empty?
-			id2label[id] = label
+def format_variants4report(var_data)
+	if var_data.nil?
+		var_ids, var_coors = nil
+	else 
+		var_ids = []
+		var_coors = {}
+		count = 0
+		var_data.each do |chr, reg| 
+			var_id = "var_#{count}"
+			var_ids << [var_id, 0]
+			var_coors[var_id] = [chr.to_s, reg[:start]]
+			count += 1
 		end
 	end
-	return profiles, id2label
+	return var_ids, var_coors
 end
 
-
-
-def get_evidence_coordinates(entity, genomic_coordinates, candidates_ids)
-	all_coordinates = genomic_coordinates[entity]
-	coords = all_coordinates.select{|id, coordinates| candidates_ids.include?(id.to_sym)}
-	return coords
+def get_genome_hotspots(similarity_matrixs, all_genomic_coordinates)
+	regions = Genomic_Feature.new(all_genomic_coordinates.values.map{|g| g[0..2]})
+	candidates_by_window, genome_windows = regions.generate_cluster_regions(:reg_overlap, 'A', 1)
+	# TODO: COMPLETE UNTIL FULL PREDICTOR
 end
 
 
-
 #############################################################################################
 ## OPTPARSE
 ############################################################################################
@@ -245,17 +142,7 @@ profiles.each do |profile_id, reference_prof|
 		coords = get_evidence_coordinates(entity, genomic_coordinates, candidates_ids)
 		all_genomic_coordinates.merge!(coords)
 	end
+	get_genome_hotspots(similarity_matrixs, all_genomic_coordinates)
 	prof_vars = profile_variants[profile_id]
-	container = {
-		profile_id: profile_id,
-		candidates: all_candidates.each{|c| c[0] = c.first.to_s},
-		genomic_coordinates: all_genomic_coordinates.transform_values{|c| c.first(2) },
-		similarity_matrixs: similarity_matrixs,
-		evidences: evidences,
-		var_ids: prof_vars.nil? ? nil : prof_vars.keys.map{|i| [i, 0]},
-		var_coordinates: prof_vars
-	}
-	report = Report_html.new(container, 'Evidence profile report')
-	report.build(template)
-	report.write(File.join(options[:output_folder], profile_id.to_s + '.html'))
+	make_report(profile_id, all_candidates, all_genomic_coordinates, similarity_matrixs, evidences, prof_vars, template, options[:output_folder])
 end

data/bin/get_network_nodes.rb

@@ -3,112 +3,34 @@
 # Code to prepare data to get the associations between pathological phenotypes (HPO) and genomic regions (SOR)
 
 ROOT_PATH = File.dirname(__FILE__)
-EXTERNAL_DATA = File.expand_path(File.join(ROOT_PATH, '..', 'external_data'))
-HPO_FILE = File.join(EXTERNAL_DATA, 'hp.obo')
 $: << File.expand_path(File.join(ROOT_PATH, '..', 'lib', 'pets'))
 
 ##############################
 #LIBRARIES
 ##############################
-require 'generalMethods.rb'
 require 'optparse'
-require 'semtools'
+require 'pets'
 
 ###############################
 #METHODS
 ###############################
 
-def loadPatientFile(patient_file, hpo, add_parents)
-	patient2phenotype = {}
-	hpo_count = {}
-	not_found = []	
-	patients_genomic_region_by_chr = {}
-	File.open(patient_file).each do |line|
-		line.chomp!
-		next if line.include?("#")
-		patient, chr, start, stop, phenotype_profile = line.split("\t", 5)
-		next if phenotype_profile.nil? #For skipping patients without phenotypes
-		phenotypes = phenotype_profile.split('|')
-		# phenotypes, rejected = hpo.translate_names2codes(phenotypes)
-		phenotypes, rejected = hpo.translate_names(phenotypes)
-		not_found = not_found | rejected
-		phenotypes.each do |hpo_code|
-			get_all_hpos(patient, hpo_code, patient2phenotype, hpo, hpo_count, add_parents) if !hpo.is_removable(hpo_code)
-		end
-		info = [patient, start.to_i, stop.to_i]
-		add_record(patients_genomic_region_by_chr, chr, info)
-	end
-	return patient2phenotype, hpo_count, not_found, patients_genomic_region_by_chr
-end
-
-
-def get_all_hpos(patient, hpo_code, patient2phenotype, hpo, hpo_count, add_parents)
-	add_record(hpo_count, hpo_code, patient)
-	add_record(patient2phenotype, patient, hpo_code)
-	if add_parents == 'root'
-		# hpo_parent_codes = hpo.get_parents(hpo_code)
-		hpo_parent_codes = hpo.get_ancestors(hpo_code)
-    	hpo_parent_codes.each do |parent_code|
-			add_record(hpo_count, parent_code, patient)
-			add_record(patient2phenotype, patient, parent_code)
-    	end	
-    end
-end
-
-def build_tripartite_network(patients2hpo, hpo_stats, ic_threshold, patients_by_cluster)
+def build_tripartite_network(patient_data, patients_by_cluster, add_parents, ont)
 	tripartite_network = []
 	patients_by_cluster.each do |patient, node_ids|
 		node_ids.each do |node_id|
 			tripartite_network << [node_id, patient] 
 		end
 	end
-	patients_list = patients_by_cluster.keys
-	patients2hpo.each do |patient, code|
-		if patients_list.include?(patient)
-		  code.each do |c|
-			tripartite_network << [c, patient] if hpo_stats[c].last >= ic_threshold 
-		  end
-		end
+	patient_data.each_profile do |id, profile|
+		profile = profile.map{|term| ont.get_ancestors(term)}.flatten.uniq if add_parents == 'root'
+	  profile.each do |term|
+			tripartite_network << [term, id] 
+	  end
 	end
 	return tripartite_network
 end
 
-def compute_hpo_stats(hpo_count, patient_number)
-	hpo_stats = {}
-	patient_hpo_ic = []
-	hpo_count.each do |hpo_code, patient_ids|
-	    hpo_freq = patient_ids.length.fdiv(patient_number) #hpo frequency in patients
-	    hpo_ic = -Math.log10(hpo_freq)
-	    hpo_stats[hpo_code] = [hpo_freq, hpo_ic]
-	    patient_ids.each do |patient_id|
-	    	patient_hpo_ic << [patient_id, hpo_code, hpo_ic]
-	    end
-	end
-	return hpo_stats, patient_hpo_ic.sort{|a,b| a.first <=> b.first}
-end
-
-def write_hash(hash, file_path, header = [])
-	File.open(file_path, 'w') do |handler|
- 		handler.puts header.join("\t") if !header.empty?
- 		hash.each do |key, array|
- 			handler.puts "#{key}\t#{array.join("\t")}"
- 		end
- 	end
-end
-
-def write_array(array, file_path)
-	File.open(file_path, 'w') do |handler|
-		array.each do |record|
-			if record.class == String
-				line = record
-			else
-				line = record.join("\t")
-			end
-			handler.puts line  
-		end
-	end
-end
-
 ##############################
 #OPTPARSE
 ##############################
@@ -117,33 +39,75 @@ options = {}
 OptionParser.new do |opts|
   opts.banner = "Usage: #{__FILE__} [options]"
 
-  options[:cluster_file] = 'cluster_coords.txt'
-  opts.on("-c", "--cluster_file PATH", "Cluster coords output file that will be used to translate SOR nodes") do |value|
-    options[:cluster_file] = File.basename(value)
-  end 
+  options[:chromosome_col] = nil
+  opts.on("-c", "--chromosome_col INTEGER/STRING", "Column name if header is true, otherwise 0-based position of the column with the chromosome") do |data|
+    options[:chromosome_col] = data
+  end
 
-  options[:excluded_hpo] = nil
-  opts.on("-e", "--excluded_hpo PATH", "List of HPO phenotypes to exclude (low informative)") do |excluded_hpo|
-    options[:excluded_hpo] = excluded_hpo
+  options[:id_col] = nil
+  opts.on("-d", "--pat_id_col INTEGER/STRING", "Column name if header is true, otherwise 0-based position of the column with the patient id") do |data|
+    options[:id_col] = data
   end
 
-  options[:patient_file] = nil
-  opts.on("-i", "--input_file PATH", "Input file with patients for parsing phenotypes to HPO codes") do |value|
-    options[:patient_file] = value
+  options[:end_col] = nil
+  opts.on("-e", "--end_col INTEGER/STRING", "Column name if header is true, otherwise 0-based position of the column with the end mutation coordinate") do |data|
+    options[:end_col] = data
+  end
+  
+ 	options[:ont_col] = nil
+  opts.on("-p", "--hpo_term_col INTEGER/STRING", "Column name if header true or 0-based position of the column with the HPO terms") do |data|
+    options[:ont_col] = data
   end
 
-  options[:mutation_type] = 'A'
-  opts.on("-m", "--mutation_type STRING", "Type of patient mutation, either it is a deletion (d) or duplication (D)") do |type|
-    options[:mutation_type] = type
+  options[:start_col] = nil
+  opts.on("-s", "--start_col INTEGER/STRING", "Column name if header is true, otherwise 0-based position of the column with the start mutation coordinate") do |data|
+    options[:start_col] = data
+  end
+
+  options[:separator] = '|'
+  opts.on("-S", "--hpo_separator STRING", "Set which character must be used to split the HPO profile. Default '|'") do |data|
+    options[:separator] = data
+  end
+
+  options[:names] = false
+  opts.on("-n", "--hpo_names", "Define if the input HPO are human readable names. Default false") do
+    options[:names] = true
+  end
+
+  options[:header] = true
+  opts.on("-H", "--header", "File has a line header. Default true") do 
+    options[:header] = false
+  end
+
+  #===================================================================
+
+  options[:input_file] = nil
+  opts.on("-i", "--input_file PATH", "Input file with patients for parsing phenotypes to HPO codes") do |value|
+    options[:input_file] = value
   end
 
   options[:output_file] = 'tripartite_network.txt'
   opts.on("-o", "--output_file PATH", "Output file for the tripartite network") do |value|
     options[:output_file] = value
+  end
+
+  options[:cluster_file] = 'cluster_coords.txt'
+  opts.on("-u", "--cluster_file PATH", "Cluster coords output file that will be used to translate SOR nodes") do |value|
+    options[:cluster_file] = File.basename(value)
   end 
 
+  options[:excluded_hpo] = nil
+  opts.on("-x", "--excluded_hpo PATH", "List of HPO phenotypes to exclude (low informative)") do |excluded_hpo|
+    options[:excluded_hpo] = excluded_hpo
+  end
+
+  options[:tag] = 'A'
+  opts.on("-m", "--mutation_type STRING", "Type of patient mutation, either it is a deletion (d) or duplication (D)") do |type|
+    options[:tag] = type
+  end
+
   options[:hpo_file] = nil
-  opts.on("-p", "--hpo_file PATH", "Input HPO file for extracting HPO codes") do |value|
+  opts.on("-O", "--hpo_file PATH", "Input HPO file for extracting HPO codes") do |value|
     options[:hpo_file] = value
   end
 
@@ -152,16 +116,6 @@ OptionParser.new do |opts|
     options[:add_parents] = value
   end 
 
-  options[:hpo_stat_file] = 'hpo_stats.txt'
-  opts.on("-s", "--hpo_stat_file PATH", "Output file with HPO codes, their frequency and CI") do |value|
-    options[:hpo_stat_file] = File.basename(value)
-  end 
-
-  options[:thresold] = 0
-  opts.on("-t", "--info_thresold FLOAT", "IC thresold to discard non informative hpo. Default: 0.") do |thresold|
-    options[:thresold] = thresold.to_f
-  end
-
   opts.on_tail("-h", "--help", "Show this message") do
     puts opts
     exit
@@ -176,27 +130,20 @@ output_folder = File.dirname(File.expand_path(options[:output_file]))
 Dir.mkdir(output_folder) if !File.exists?(output_folder)
 
 hpo_file = options[:hpo_file]
-hpo_file = ENV['hpo_file'] if hpo_file.nil?
-hpo_file = HPO_FILE if hpo_file.nil?
-
-# hpo = Ontology.new
-# hpo.load_black_list(options[:excluded_hpo]) if !options[:excluded_hpo].nil?
-# hpo.load_data(hpo_file)
-if !options[:excluded_hpo].nil?
-	hpo = Ontology.new(file: hpo_file, load_file: true, removable_terms: read_excluded_hpo_file(options[:excluded_hpo]))
-else
-	hpo = Ontology.new(file: hpo_file, load_file: true)
-end
-patients2hpo, hpo_count, not_found, chr_patients_genomic_region = loadPatientFile(options[:patient_file], hpo, options[:add_parents])
-
-hpo_stats, patient_hpo_ic = compute_hpo_stats(hpo_count, patients2hpo.length)
-patients_by_cluster, sors = generate_cluster_regions(chr_patients_genomic_region, options[:mutation_type])
-
-tripartite_network = build_tripartite_network(patients2hpo, hpo_stats, options[:thresold], patients_by_cluster)
-
-# write_array(not_found - hpo.excluded_codes, File.join(output_folder, 'missing_hpo_names'))
-write_array(not_found - hpo.removable_terms, File.join(output_folder, 'missing_hpo_names'))
+hpo_file = !ENV['hpo_file'].nil? ? ENV['hpo_file'] : HPO_FILE if hpo_file.nil?
+Cohort.load_ontology(:hpo, hpo_file, options[:excluded_hpo])
+Cohort.act_ont = :hpo
+hpo = Cohort.get_ontology(Cohort.act_ont)
+
+patient_data, rejected_hpos_L, rejected_patients_L = Cohort_Parser.load(options)
+rejected_hpos_C, rejected_patients_C = patient_data.check
+rejected_hpos = rejected_hpos_L | rejected_hpos_C
+rejected_patients = rejected_patients_L + rejected_patients_C
+patient_data.remove_incomplete_records
+patient_data.index_vars
+patients_by_cluster, sors = patient_data.generate_cluster_regions(:reg_overlap, options[:tag], 1)
+tripartite_network = build_tripartite_network(patient_data, patients_by_cluster, options[:add_parents], hpo)
+
+write_array(rejected_hpos, File.join(output_folder, 'missing_hpo_names'))
 write_array(sors, File.join(output_folder, options[:cluster_file]))
-write_hash(hpo_stats.select{|hp_code, stats| stats.last > options[:thresold]}, File.join(output_folder, options[:hpo_stat_file]), %w[HPOcode Frequency IC])
-write_array(tripartite_network, options[:output_file])
-write_array(patient_hpo_ic, File.join(output_folder, 'filtered_hpo.txt'))
+write_array(tripartite_network, options[:output_file])

data/bin/get_sorted_profs.rb

@@ -1,33 +1,11 @@
 #! /usr/bin/env ruby
 
-
 ROOT_PATH = File.dirname(__FILE__)
-REPORT_FOLDER = File.expand_path(File.join(ROOT_PATH, '..', 'templates'))
-EXTERNAL_DATA = File.expand_path(File.join(ROOT_PATH, '..', 'external_data'))
-HPO_FILE = File.join(EXTERNAL_DATA, 'hp.json')
 $: << File.expand_path(File.join(ROOT_PATH, '..', 'lib', 'pets'))
 
 require 'optparse'
 require 'report_html'
-require 'semtools'
-require 'generalMethods.rb'
-
-#############################################################################################
-## METHODS
-############################################################################################
-def procces_patient_data(patient_data, hpo)
-	clean_profiles = {}
-	all_hpo = []
-	patient_data.each do |pat_id, data|
-		profile = hpo.clean_profile_hard(data.first.map{|c| c.to_sym})
-		if !profile.empty?
-			clean_profiles[pat_id] = profile
-			all_hpo.concat(profile)
-		end
-	end
-	ref_prof = hpo.clean_profile_hard(all_hpo.uniq)
-	return ref_prof, clean_profiles
-end
+require 'pets'
 
 #############################################################################################
 ## OPTPARSE
@@ -42,9 +20,9 @@ OptionParser.new do |opts|
     options[:chromosome_col] = data
   end
 
-  options[:pat_id_col] = nil
+  options[:id_col] = nil
   opts.on("-d", "--pat_id_col INTEGER/STRING", "Column name if header is true, otherwise 0-based position of the column with the patient id") do |data|
-    options[:pat_id_col] = data
+    options[:id_col] = data
   end
 
   options[:end_col] = nil
@@ -67,9 +45,9 @@ OptionParser.new do |opts|
     options[:input_file] = value
   end
 
-  options[:hpo_col] = nil
+  options[:ont_col] = nil
   opts.on("-p", "--hpo_term_col INTEGER/STRING", "Column name if header true or 0-based position of the column with the HPO terms") do |data|
-    options[:hpo_col] = data
+    options[:ont_col] = data
   end
 
   options[:start_col] = nil
@@ -77,9 +55,14 @@ OptionParser.new do |opts|
     options[:start_col] = data
   end
 
-  options[:hpo_separator] = '|'
+  options[:separator] = '|'
   opts.on("-S", "--hpo_separator STRING", "Set which character must be used to split the HPO profile. Default '|'") do |data|
-    options[:hpo_separator] = data
+    options[:separator] = data
+  end
+
+  options[:term_freq] = 0
+  opts.on("-f", "--general_prof_freq INTEGER", "When reference profile is not given, a general ine is computed with all profiles. If a freq is defined (0-1), all terms with freq minor than limit are removed") do |data|
+    options[:term_freq] = data.to_i
   end
 
   options[:matrix_limits] = [20, 40]
@@ -101,15 +84,21 @@ end.parse!
 #############################################################################################
 ## MAIN
 ############################################################################################
-patient_data = load_patient_cohort(options)
 
 hpo_file = !ENV['hpo_file'].nil? ? ENV['hpo_file'] : HPO_FILE
-hpo = Ontology.new
-hpo.read(hpo_file)
-
-ref_profile, clean_profiles = procces_patient_data(patient_data, hpo)
-ref_profile = hpo.clean_profile_hard(options[:ref_prof]) if !options[:ref_prof].nil?
-hpo.load_profiles({ref: ref_profile})
+Cohort.load_ontology(:hpo, hpo_file)
+Cohort.act_ont = :hpo
+hpo = Cohort.get_ontology(Cohort.act_ont)
+patient_data, _, _ = Cohort_Parser.load(options)
+patient_data.check(hard=true)
+
+clean_profiles = patient_data.profiles
+if !options[:ref_prof].nil?
+  ref_profile = hpo.clean_profile_hard(options[:ref_prof])
+else
+  ref_profile = patient_data.get_general_profile(options[:term_freq])
+end
+hpo.load_profiles({ref: ref_profile}, reset_stored: true)
 
 similarities = hpo.compare_profiles(external_profiles: clean_profiles, sim_type: :lin, bidirectional: false)
 

data/bin/install_deps.rb

@@ -0,0 +1,7 @@
+#! /usr/bin/env ruby
+
+ROOT_PATH = File.dirname(__FILE__)
+EXTERNAL_CODE = File.expand_path(File.join(ROOT_PATH, '..', 'external_code')
+$: << File.expand_path(File.join(ROOT_PATH, '..', 'lib', 'pets'))
+
+system_call(EXTERNAL_CODE, 'install_R_dependencies.R')