pets 0.2.3 → 0.2.5

data/bin/evidence_profiler.rb

@@ -1,166 +1,102 @@
 #! /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
+def load_pathogenic_scores(path)
+	scores = {}
+	File.open(path).each do |line|
+		feature, score = line.split("\t")
+		scores[feature] = score.to_f
 	end
-	return profiles
+	return scores
 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
+def get_evidence_coordinates(entity, genomic_coordinates, candidates_ids)
+	coords = nil
+	all_coordinates = genomic_coordinates[entity]
+	coords = all_coordinates.select{|id, coordinates| candidates_ids.include?(id.to_sym)} if !all_coordinates.nil?
+	return coords
 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 make_report(profile_id, all_candidates, all_genomic_coordinates, similarity_matrixs, 
+							evidences, prof_vars, hotspots_with_pat_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,
+		hotspot_table: hotspots_with_pat_vars
+	}
+	report = Report_html.new(container, 'Evidence profile report')
+	report.build(template)
+	report.write(File.join(output, profile_id.to_s + '.html'))
 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]
+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 coordinates
+	return var_ids, var_coors
 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 generate_prediction(similarity_matrixs, all_genomic_coordinates, prof_vars)
+	hotspots_with_pat_vars = []
+	if !prof_vars.nil?
+		phen_regions = Genomic_Feature.hash2genomic_feature(all_genomic_coordinates){|k, v| v[0..2].concat([k])}
+		phen_candidates_by_hotspot, phen_genome_hotspots = phen_regions.generate_cluster_regions(:reg_overlap, 'A', 0, true)
+		genome_matches = phen_genome_hotspots.match(prof_vars)
+		hotspot_with_phen_candidates = invert_hash(phen_candidates_by_hotspot) 
+		genome_matches.each do |hotspot_id, pat_vars|
+			reg = phen_genome_hotspots.region_by_to(hotspot_id)
+			coords = [reg[:chr], reg[:start], reg[:stop]]
+			hotspots_with_pat_vars << [hotspot_id, coords, hotspot_with_phen_candidates[hotspot_id], pat_vars]
 		end
+		# TODO: see to use original similarities without use top candidates in similarity_matrixs
+		# TODO: COMPLETE UNTIL FULL PREDICTOR
 	end
-	return profiles, id2label
+	return hotspots_with_pat_vars
 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 invert_hash(h)
+	new_h = {}
+	h.each do |k, vals|
+		vals.each do |v|
+			query = new_h[v]
+			if query.nil?
+				new_h[v] = [k]
+			else
+				query << k
+			end
+		end
+	end
+	return new_h
 end
 
-
-
 #############################################################################################
 ## OPTPARSE
 ############################################################################################
@@ -199,6 +135,11 @@ OptionParser.new do |opts|
     options[:variant_data] = item
   end
 
+  options[:pathogenic_scores] = nil # TODO: Generalize to a folder with a table per patient
+  opts.on("-P", "--pathogenic_scores PATH", 'File with genome features an their pathogenic scores') do |item|
+    options[:pathogenic_scores] = item
+  end
+
  opts.on_tail("-h", "--help", "Show this message") do
     puts opts
     exit
@@ -211,12 +152,12 @@ end.parse!
 ############################################################################################
 
 hpo_file = !ENV['hpo_file'].nil? ? ENV['hpo_file'] : HPO_FILE
-hpo = Ontology.new
-hpo.read(hpo_file)
+hpo = Ontology.new(file: hpo_file, load_file: true)
 
 profiles = load_profiles(options[:profiles_file], hpo)
 profile_variants = options[:variant_data].nil? ? {} : load_variants(options[:variant_data])
 evidences, genomic_coordinates = load_evidences(options[:evidences], hpo)
+pathogenic_scores = options[:pathogenic_scores].nil? ? {} : load_pathogenic_scores(options[:pathogenic_scores])
 
 hpo.load_profiles(profiles)
 evidences_similarity = {}
@@ -225,7 +166,8 @@ evidences.each do |pair, data|
 	if profile_type == 'HP'
 		evidence_profiles = data[:prof]
 		evidence_profiles.transform_keys!{|prof_id, terms| prof_id.to_sym}
-		evidences_similarity[pair] = hpo.compare_profiles(external_profiles: evidence_profiles, sim_type: :lin, bidirectional: false)
+		similarities = hpo.compare_profiles(external_profiles: evidence_profiles, sim_type: :lin, bidirectional: false)
+		evidences_similarity[pair] = similarities if !similarities.empty?
 	end
 end 
 
@@ -239,23 +181,33 @@ profiles.each do |profile_id, reference_prof|
 		entity = pair.split('_').first
 		similarities = ev_profiles_similarity[profile_id.to_sym]
 		candidate_sim_matrix, candidates, candidates_ids = get_similarity_matrix(reference_prof, similarities, evidences[pair][:prof], hpo, 40, 40)
-		candidate_sim_matrix.unshift(['HP'] + candidates_ids)	
+		coords = get_evidence_coordinates(entity, genomic_coordinates, candidates_ids)
+		candidate_sim_matrix.unshift(['HP'] + candidates_ids)
+		if !pathogenic_scores.empty? # priorize by pathogenic scores
+			candidate_sim_matrix_patho, candidates_patho, candidates_ids_patho = get_similarity_matrix(
+				reference_prof, similarities, 
+				evidences[pair][:prof], hpo, 40, 40, 
+				other_scores = pathogenic_scores, id2label = evidences[pair][:id2lab])
+			if !candidate_sim_matrix_patho.empty?
+				candidate_sim_matrix_patho.unshift(['HP'] + candidates_ids_patho)	
+				similarity_matrixs[pair + '_path_vars'] = candidate_sim_matrix_patho
+				evidences[pair + '_path_vars'] = evidences[pair]
+			end
+		end
+		next if coords.nil?
 		all_candidates.concat(candidates)
 		similarity_matrixs[pair] = candidate_sim_matrix
-		coords = get_evidence_coordinates(entity, genomic_coordinates, candidates_ids)
 		all_genomic_coordinates.merge!(coords)
 	end
 	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'))
+	hotspots_with_pat_vars = generate_prediction(similarity_matrixs, all_genomic_coordinates, prof_vars)
+	make_report(
+		profile_id, 
+		all_candidates, 
+		all_genomic_coordinates, 
+		similarity_matrixs, 
+		evidences, prof_vars,
+		hotspots_with_pat_vars,
+		template, options[:output_folder]
+	)
 end

data/bin/get_gen_features.rb

@@ -0,0 +1,146 @@
+#! /usr/bin/env ruby
+
+ROOT_PATH = File.dirname(__FILE__)
+$: << File.expand_path(File.join(ROOT_PATH, '..', 'lib', 'pets'))
+
+require 'optparse'
+require 'pets'
+
+##################################
+## METHODS
+##################################
+
+def get_data(options)
+	fields2extract = get_fields2extract(options)
+	field_numbers = fields2extract.values
+	records = read_records(options, fields2extract, field_numbers)
+end
+
+def read_records(options, fields2extract, field_numbers) # Modified from cohort_parset
+	records = []
+	count = 0
+	File.open(options[:input_file]).each do |line|
+		line.chomp!
+		if options[:header] && count == 0
+			line.gsub!(/#\s*/,'') # correct comment like	headers
+			field_names = line.split("\t")
+			get_field_numbers2extract(field_names, fields2extract)
+			field_numbers = fields2extract.values
+		else
+			fields = line.split("\t")
+			record = field_numbers.map{|n| fields[n]}
+			if fields2extract[:id_col].nil?
+				id = "rec_#{count}" #generate ids
+			else
+				id = record.shift
+			end
+			record[1] = record[1].to_i 
+			record[2] = record[2].to_i
+			record << id
+			records << record
+		end
+		count +=1
+	end
+	return records
+end
+
+def get_fields2extract(options)
+	fields2extract = {}
+	[:id_col, :chromosome_col, :start_col, :end_col].each do |field|
+		col = options[field]
+		if !col.nil?
+			col = col.to_i if !options[:header]
+			fields2extract[field] = col
+		end
+	end
+	return fields2extract
+end
+
+def get_field_numbers2extract(field_names, fields2extract)
+	fields2extract.each do |field, name|
+		fields2extract[field] = field_names.index(name)
+	end
+end
+
+##########################
+#OPT-PARSER
+##########################
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: #{__FILE__} [options]"
+
+  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[:id_col] = nil
+  opts.on("-d", "--id_col INTEGER/STRING", "Column name if header is true, otherwise 0-based position of the column with the id") do |data|
+    options[:id_col] = data
+  end
+
+  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[:header] = true
+  #chr\tstart\tstop
+  opts.on("-H", "--header", "Set if the file has a line header. Default true") do 
+    options[:header] = false
+  end
+
+  options[:input_file] = nil
+  opts.on("-i", "--input_file PATH", "Input file path") do |data|
+    options[:input_file] = data
+  end
+
+  options[:reference_file] = nil
+  opts.on("-r", "--reference_file PATH", "Reference file with genome annotation") do |data|
+    options[:reference_file] = data
+  end
+
+  options[:output_file] = nil
+  opts.on("-o", "--output_file PATH", "Output file with patient data") do |data|
+    options[:output_file] = data
+  end
+
+  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[:feature_type] = nil
+  opts.on("-t", "--feature_type STRING", "Keep features from reference whose are tagged with this feature type") do |data|
+  	options[:feature_type] = data
+  end
+
+  options[:feature_name] = nil
+  opts.on("-n", "--feature_name STRING", "Use this feature id that is present in attributes/annotation field of reference") do |data|
+  	options[:feature_name] = data
+  end
+
+  opts.on_tail("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+
+end.parse!
+
+regions = Genomic_Feature.new(get_data(options))
+Genomic_Feature.add_reference(
+	Reference_parser.load(
+		options[:reference_file], 
+		feature_type: options[:feature_type]
+	)
+)
+gene_features = regions.get_features(attr_type: options[:feature_name])
+
+File.open(options[:output_file], 'w') do |f|
+	gene_features.each do |id, feat_ids|
+		feat_ids.each do |ft_id|
+			f.puts "#{id}\t#{ft_id}"
+		end
+	end 
+end