publisci 0.1.2

data/lib/bio-publisci/query/query_helper.rb

@@ -0,0 +1,123 @@
+module RDF
+	class Query
+		class Solutions
+			def to_h
+				arr=[]
+	    	self.map{|solution|
+	    		h={}
+	    		solution.map{|element|
+						 	h[element[0]] = element[1]
+	    		}
+	    		arr << h
+	    	}
+	    	arr
+			end
+		end
+	end
+end
+
+module PubliSci
+  #.gsub(/^\s+/,'')
+  module Query
+    def vocabulary
+      {
+        base: RDF::Vocabulary.new('<http://www.rqtl.org/ns/#>'),
+        qb:   RDF::Vocabulary.new("http://purl.org/linked-data/cube#"),
+        rdf:  RDF::Vocabulary.new('http://www.w3.org/1999/02/22-rdf-syntax-ns#'),
+        rdfs: RDF::Vocabulary.new('http://www.w3.org/2000/01/rdf-schema#'),
+        prop: RDF::Vocabulary.new('http://www.rqtl.org/dc/properties/'),
+        cs:   RDF::Vocabulary.new('http://www.rqtl.org/dc/cs')
+      }
+    end
+
+
+
+    # def execute_internal(query,repo)
+    #   SPARQL.execute(query,repo)
+    # end
+
+    def execute(string,store,type=:fourstore)
+			if store.is_a?(PubliSci::Store) || store.is_a?(RDF::FourStore)
+				sparql = SPARQL::Client.new(store.url+"/sparql/")
+      elsif type == :graph || store.is_a?(RDF::Graph) || store.is_a?(RDF::Repository)
+        sparql = SPARQL::Client.new(store)
+			elsif type == :fourstore
+				sparql = SPARQL::Client.new(store+"/sparql/")
+      end
+      sparql.query(string)
+    end
+
+    def execute_from_file(file,store,type=:fourstore,substitutions={})
+      if Gem::Dependency.new('bio-publisci').matching_specs.size > 0
+        queries_dir = Gem::Specification.find_by_name("bio-publisci").gem_dir + "/resources/queries/"
+      else
+        queries_dir = File.dirname(__FILE__) + '/../../../resources/queries/'
+      end
+      if File.exist?(file)
+        string = IO.read(file)
+      elsif File.exist?(queries_dir + file)
+        string = IO.read(queries_dir + file)
+      elsif File.exist?(queries_dir + file + '.rq')
+        string = IO.read(queries_dir + file + '.rq')
+      else
+        raise "couldn't find query for #{file}"
+      end
+
+      substitutions.map{|k,v|
+        string = string.gsub(k,v)
+      }
+    	execute(string, store, type)
+    end
+
+#     def prefixes
+#       <<-EOF
+# PREFIX ns:     <http://www.rqtl.org/ns/#>
+# PREFIX qb:   <http://purl.org/linked-data/cube#>
+# PREFIX rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+# PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+# PREFIX prop: <http://www.rqtl.org/dc/properties/>
+# PREFIX cs:   <http://www.rqtl.org/dc/cs/>
+# PREFIX skos: <http://www.w3.org/2004/02/skos/core#>
+
+#       EOF
+#     end
+
+    def property_values(var, property)
+      str = prefixes
+      str << <<-EOS
+SELECT ?val WHERE {
+  ?obs qb:dataSet ns:dataset-#{var} ;
+      prop:#{property} ?val ;
+}
+      EOS
+      str
+    end
+
+    def row_names(var)
+      str = prefixes
+      str << <<-EOS
+SELECT ?label WHERE {
+  ?obs qb:dataSet ns:dataset-#{var} ;
+       prop:refRow ?row .
+  ?row skos:prefLabel ?label .
+}
+      EOS
+    end
+
+    # Currently will say "___ Component", needs further parsing
+    def property_names(var)
+      str = prefixes
+      str << <<-EOS
+SELECT DISTINCT ?label WHERE {
+  ns:dsd-#{var} qb:component ?c .
+  ?c rdfs:label ?label
+}
+      EOS
+    end
+
+  end
+
+  class QueryHelper
+    extend PubliSci::Query
+  end
+end

data/lib/bio-publisci/r_client.rb

@@ -0,0 +1,54 @@
+module PubliSci
+	module Rconnect
+
+		def connect(address=nil)
+			if address
+				Rserve::Connection.new(address)
+			else
+				Rserve::Connection.new
+			end
+		end
+
+		def load_workspace(connection,loc=Dir.home,file=".RData")
+			loc = File.join(loc,file)
+			connection.eval "load(\"#{loc}\")"
+		end
+
+		def get(connection, instruction)
+			connection.eval instruction
+		end
+
+		def get_vars(connection)
+			connection.eval("ls()")
+		end
+
+	end
+
+	class Client
+		include PubliSci::Rconnect
+    attr :R
+
+		def initialize(auto=true, loc=Dir.home)
+      @R = connect
+			@loc = loc
+			load_ws if auto
+			puts "vars: #{vars.payload}" if auto
+		end
+
+		def load_ws
+			load_workspace(@R, @loc)
+		end
+
+		def get_var(var)
+			get(@R,var)
+		end
+
+		def get_ws
+			"#{@loc}/.RData"
+		end
+
+		def vars
+			get_vars(@R)
+		end
+  end
+end

data/lib/bio-publisci/readers/arff.rb

@@ -0,0 +1,49 @@
+module PubliSci
+		module Readers
+		class ARFF
+			include PubliSci::Dataset::DataCube
+
+			def generate_n3(arff, options={})
+				arff = IO.read(arff) if File.exist? arff
+				options[:no_labels] = true # unless options[:no_labels] == nil
+				@options = options
+				comps =  components(arff)
+				obs = data(arff, comps.keys)
+				generate(comps.reject{|c| comps[c][:codes]}.keys, comps.select{|c| comps[c][:codes]}.keys, comps.select{|c| comps[c][:codes]}.keys, obs, (1..obs.first[1].size).to_a, relation(arff), options)
+			end
+
+			def relation(arff)
+				arff.match(/@relation.+/i).to_a.first.split.last
+			end
+
+			def components(arff)
+				#still needs support for quoted strings with whitespace
+				h ={}
+				arff.split("\n").select{|lin| lin =~ /^@ATTRIBUTE/i}.map{|line|
+					if line =~ /\{.*}/
+						name = line.match(/\s.*/).to_a.first.strip.split.first
+						type = :coded
+						codes = line.match(/\{.*}/).to_a.first[1..-2].split(',')
+						h[name] = {type: type, codes: codes}
+					else
+						name = line.split[1]
+						type = line.split[2]
+						h[name] = {type: type}
+					end
+				}
+				h
+			end
+
+			def data(arff, attributes)
+				lines = arff.split("\n")
+				data_lines = lines[lines.index(lines.select{|line| line =~ /^@DATA/i}.first)+1..-1]
+				h=attributes.inject({}){|ha,attrib| ha[attrib] = []; ha}
+				data_lines.map{|line|
+					line = line.split ','
+					attributes.each_with_index{|a,i| h[a] << line[i]}
+				}
+				h
+			end
+		end
+	end
+end

data/lib/bio-publisci/readers/base.rb

@@ -0,0 +1,57 @@
+module PubliSci
+  module Readers
+    class Base
+      include PubliSci::Query
+      include PubliSci::Parser
+      include PubliSci::Analyzer
+      include PubliSci::Interactive
+      include PubliSci::Dataset::DataCube
+
+      #should be overridden if extra processing/input is required
+      def automatic(*args)
+        generate_n3(args[0],Hash[*args[1..-2]])
+      end
+
+      def generate_n3(*args)
+        raise "#{self} does not implement a generate_n3 method!"
+      end
+
+      def sio_value(type,value)
+        [
+          ["a", type],
+          ["http://semanticscience.org/resource/SIO_000300",value]
+        ]
+      end
+
+      def sio_attribute(attribute_type,value,data_type=nil)
+        inner = [
+          "http://semanticscience.org/resource/SIO_000300",value
+        ]
+        if data_type
+          inner = [["a", data_type], inner]
+        end
+        
+        outer = 
+        [
+          "http://semanticscience.org/resource/SIO_000008",
+            inner
+        ]
+
+        if attribute_type
+          outer = [["a", attribute_type], outer] 
+        end
+
+        # puts "#{outer}"
+        outer
+      end
+
+      def next_label
+        if @__current_label
+          @__current_label += 1
+        else
+          @__current_label = 0
+        end
+      end
+    end
+  end
+end

data/lib/bio-publisci/readers/csv.rb

@@ -0,0 +1,88 @@
+module PubliSci
+	module Readers
+		class CSV < Base
+      def automatic(file=nil,dataset_name=nil,options={},interactive=true)
+        #to do
+        # puts "f #{file} \n ds #{dataset_name} opts #{options}"
+
+        unless file || !interactive
+          puts "Input file?"
+          file = gets.chomp
+        end
+
+        raise "CSV reader needs an input file" unless file && file.size > 0
+
+
+        unless dataset_name
+          if interactive
+            dataset_name = interact("Dataset name?","#{File.basename(file).split('.').first}"){|sel| File.basename(file).split('.').first }
+          else
+            dataset_name = File.basename(file).split('.').first
+          end
+        end
+
+
+        categories = ::CSV.read(file)[0]
+
+
+        unless options[:dimensions] || !interactive
+          options[:dimensions] = Array(interact("Dimensions?",categories[0],categories))
+        end
+
+        unless options[:measures] || !interactive
+          meas = categories - (options[:dimensions] || [categories[0]])
+          selection = interact("Measures?",meas,meas){|s| nil}
+          options[:measures] = Array(selection) unless selection == nil
+        end
+
+        generate_n3(file,dataset_name,options)
+      end
+
+			def generate_n3(file, dataset_name, options={})
+				@data = ::CSV.read(file)
+				@options = options
+				generate(measures, dimensions, codes, observation_data, observation_labels, dataset_name, options)
+			end
+
+			def dimensions
+				@options[:dimensions] || [@data[0][0]]
+			end
+
+			def codes
+				@options[:codes] || dimensions()
+			end
+
+			def measures
+				@options[:measures] || @data[0] - dimensions()
+			end
+
+			def observation_labels
+				if @options[:label_column]
+					tmp = @data.dup
+					tmp.shift
+					tmp.map{|row|
+						row[@options[:label_column]]
+					}
+				else
+					(1..@data.size - 1).to_a
+				end
+			end
+
+			def observation_data
+				obs = {}
+				@data[0].map{|label|
+					obs[label] = []
+				}
+				tmp = @data.dup
+				tmp.shift
+
+				tmp.map{|row|
+					row.each_with_index{|entry,i|
+						obs[@data[0][i]] << entry
+					}
+				}
+				obs
+			end
+		end
+	end
+end

data/lib/bio-publisci/readers/dataframe.rb

@@ -0,0 +1,67 @@
+module PubliSci
+	module Readers
+		class Dataframe
+      include PubliSci::Dataset::DataCube
+			include PubliSci::Readers::Output
+
+			# def initialize(var)
+			# 	@var = var
+			# end
+
+			def generate_n3(rexp, var, options={})
+				@rexp = rexp
+        options[:type] ||= :string
+        @options = options
+				output(generate(measures, dimensions, codes, observation_data, observation_labels, var, options), options)
+			end
+
+			def dimensions
+				if @options[:dimensions]
+					@options[:dimensions]
+				elsif @options[:row_label]
+					[@options[:row_label]]
+				else
+					["refRow"]
+				end
+			end
+
+			def codes
+				if @options[:codes]
+					@options[:codes]
+				elsif @options[:row_label]
+					[@options[:row_label]]
+				else
+					["refRow"]
+				end
+			end
+
+			def measures
+				if @options[:dimensions]
+					if @options[:measures]
+						@options[:measures] - @options[:dimensions]
+					else
+						@rexp.payload.names - @options[:dimensions]
+					end
+				else
+					@options[:measures] || @rexp.payload.names
+				end
+			end
+
+			def observation_labels
+				row_names = @rexp.attr.payload["row.names"].to_ruby
+	      row_names = (1..@rexp.payload.first.to_ruby.size).to_a unless row_names.first
+	      row_names
+			end
+
+			def observation_data
+
+				data = {}
+				@rexp.payload.names.map{|name|
+					data[name] = @rexp.payload[name].to_ruby
+				}
+				data[@options[:row_label] || "refRow"] = observation_labels()
+				data
+			end
+		end
+	end
+end

data/lib/bio-publisci/readers/maf.rb

@@ -0,0 +1,199 @@
+module PubliSci
+  module Readers
+    class MAF < Base
+    COLUMN_NAMES = %w{ Hugo_Symbol Entrez_Gene_Id Center NCBI_Build Chromosome Start_Position End_Position Strand Variant_Classification Variant_Type Reference_Allele Tumor_Seq_Allele1 Tumor_Seq_Allele2 dbSNP_RS  dbSNP_Val_Status Tumor_Sample_Barcode Matched_Norm_Sample_Barcode Match_Norm_Seq_Allele1  Match_Norm_Seq_Allele2  Tumor_Validation_Allele1  Tumor_Validation_Allele2  Match_Norm_Validation_Allele1 Match_Norm_Validation_Allele2 Verification_Status Validation_Status Mutation_Status Sequencing_Phase  Sequence_Source Validation_Method Score BAM_File  Sequencer Tumor_Sample_UUID Matched_Norm_Sample_UUID patient_id sample_id}
+
+    COMPONENT_RANGES = { "Tumor_Sample_Barcode" => "xsd:string", "Start_position" => "xsd:int", "Center" => "xsd:string", "NCBI_Build" => "xsd:int", "Chromosome" => "xsd:int" }
+
+    TCGA_CODES =
+      {
+        "Variant_Classification" => %w{Frame_Shift_Del Frame_Shift_Ins In_Frame_Del In_Frame_Ins Missense_Mutation Nonsense_Mutation Silent Splice_Site Translation_Start_Site Nonstop_Mutation 3'UTR 3'Flank 5'UTR 5'Flank IGR1  Intron RNA Targeted_Region},
+        "Variant_Type" => %w{SNP DNP TNP ONP INS DEL Consolidated},
+        "dbSNP_Val_Status" => %w{by1000genomes by2Hit2Allele byCluster byFrequency byHapMap byOtherPop bySubmitter alternate_allele},
+        "Verification_Status" => %w{Verified, Unknown},
+        "Validation_Status" => %w{Untested Inconclusive Valid Invalid},
+        "Mutation_Status" => %w{None Germline Somatic LOH Post-transcriptional modification Unknown},
+        "Sequence_Source" => %w{WGS WGA WXS RNA-Seq miRNA-Seq Bisulfite-Seq VALIDATION Other ncRNA-Seq WCS CLONE POOLCLONE AMPLICON CLONEEND FINISHING ChIP-Seq MNase-Seq DNase-Hypersensitivity EST FL-cDNA CTS MRE-Seq MeDIP-Seq MBD-Seq Tn-Seq FAIRE-seq SELEX RIP-Seq ChIA-PET},
+        "Sequencer" => ["Illumina GAIIx", "Illumina HiSeq", "SOLID", "454", "ABI 3730xl", "Ion Torrent PGM", "Ion Torrent Proton", "PacBio RS", "Illumina MiSeq", "Illumina HiSeq 2500", "454 GS FLX Titanium", "AB SOLiD 4 System" ]
+      }
+
+      def generate_n3(input_file, options={})
+
+        dataset_name = options[:dataset_name] || nil
+        output = options[:output] || :file
+        output_base = options[:output_base] || nil
+
+        @dimensions = %w{Variant_Classification Variant_Type dbSNP_Val_Status Verification_Status Validation_Status Mutation_Status Sequence_Source Sequencer}
+        # @codes = %w{Variant_Classification Variant_Type}
+        @codes = @dimensions
+        @measures = (COLUMN_NAMES - @dimensions - @codes)
+        @dataset_name ||= File.basename(input_file,'.*')
+        @barcode_index = COLUMN_NAMES.index('Tumor_Sample_Barcode')
+
+        options[:no_labels] ||= true
+        options[:lookup_hugo] ||= false
+        options[:complex_objects] ||= false
+        options[:ranges] ||= COMPONENT_RANGES
+
+
+        if output == :print
+          str = structure(options)
+          f = open(input_file)
+          n = 0
+          f.each_line{|line|
+            processed = process_line(line,n.to_s,options)
+            str << processed.first if processed
+            n +=1
+          }
+          str
+        else
+          # TODO - allow multi file / separate structure output for very large datasets
+          # open("#{file_base}_structure.ttl",'w'){|f| f.write structure(options)}
+          file_base = output_base || @dataset_name
+
+          out = open("#{file_base}.ttl",'w')
+          out.write(structure(options))
+          f = open(input_file)
+          n = 0
+          f.each_line{|line|
+            processed = process_line(line,n.to_s,options)
+            out.write(processed.first) if processed
+            n += 1
+          }
+          if options[:lookup_hugo]
+            post_process(out)
+          else
+            out
+          end
+        end
+      end
+
+      def process_line(line,label,options)
+        unless line[0] == "#" || line[0..3] == "Hugo"
+          entry = ::CSV.parse(line, {col_sep: "\t"}).flatten[0..(COLUMN_NAMES.length-3)]
+
+          entry = (entry.fill(nil,entry.length...COLUMN_NAMES.length-2) + parse_barcode(entry[@barcode_index])).flatten
+
+          entry[0] = "http://identifiers.org/hgnc.symbol/#{entry[0]}" if entry[0]
+
+          # A 0 in the entrez-id column appears to mean null
+          col=1
+          entry[col] = nil if entry[col] == '0'
+          entry[col] = "http://identifiers.org/ncbigene/#{entry[col]}" if entry[col]
+
+          # Only link non-novel dbSNP entries
+          col = COLUMN_NAMES.index('dbSNP_RS')
+          if entry[col] && entry[col][0..1] == "rs"
+            entry[col] = "http://identifiers.org/dbsnp/#{entry[col].gsub('rs','')}"
+          end
+
+          # optionally create typed objects using sio nodes
+          if options[:complex_objects]
+            entry = sio_values(entry)
+          end
+
+          data = {}
+          COLUMN_NAMES.each_with_index{|col,i|
+            data[col] = [entry[i]]
+          }
+
+          observations(@measures,@dimensions,@codes,data,[label],@dataset_name,options)
+        end
+      end
+
+      def sio_values(entry)
+        entry[0] = sio_value('http://edamontology.org/data_1791',entry[0]) if entry[0]
+
+        # Link entrez genes
+        col=1
+        entry[col] = sio_value("http://identifiers.org/ncbigene",entry[col]) if entry[col]
+
+        col = COLUMN_NAMES.index('dbSNP_RS')
+        entry[col] = sio_value("http://identifiers.org/dbsnp", entry[col])
+
+        # test SIO attributes for chromosome
+        col = COLUMN_NAMES.index('Chromosome')
+        entry[col] = sio_value("http://purl.org/obo/owl/SO#SO_0000340",entry[col])
+
+
+
+        # More SIO attrtibutes for alleles
+        %w{Reference_Allele Tumor_Seq_Allele1 Tumor_Seq_Allele2 Match_Norm_Seq_Allele1 Match_Norm_Seq_Allele2}.each{|name|
+          col = COLUMN_NAMES.index(name)
+          entry[col] = sio_value("http://purl.org/obo/owl/SO#SO_0001023",entry[col])
+        }
+
+        col = COLUMN_NAMES.index("Strand")
+        entry[col] = sio_attribute("http://edamontology.org/data_0853",entry[col])
+
+        col = COLUMN_NAMES.index("Center")
+        entry[col] = sio_attribute("foaf:homepage",entry[col])
+        # entry[col] = [
+        #   ["a", "foaf:Organization"],
+        #   ["foaf:homepage", entry[col]],
+        # ]
+
+        # Use faldo for locations End_Position
+        col = COLUMN_NAMES.index("Start_Position")
+        entry[col] = sio_attribute("http://biohackathon.org/resource/faldo#begin", entry[col],"http://biohackathon.org/resource/faldo#Position")
+
+        col = COLUMN_NAMES.index("End_Position")
+        entry[col] = sio_attribute("http://biohackathon.org/resource/faldo#end", entry[col],"http://biohackathon.org/resource/faldo#Position")
+
+        entry
+      end
+
+      def column_replace(entry,column,prefix,value=nil)
+        if value
+          entry[COLUMN_NAMES.index(column)] = prefix + value
+        else
+          entry[COLUMN_NAMES.index(column)] += prefix
+        end
+      end
+
+      def official_symbol(hugo_symbol)
+        qry = <<-EOF
+
+        SELECT distinct ?official where {
+         {?hgnc <http://bio2rdf.org/hgnc_vocabulary:approved_symbol> "#{hugo_symbol}"}
+         UNION
+         {?hgnc <http://bio2rdf.org/hgnc_vocabulary:synonym> "#{hugo_symbol}"}
+
+         ?hgnc <http://bio2rdf.org/hgnc_vocabulary:approved_symbol> ?official
+        }
+
+        EOF
+
+        sparql = SPARQL::Client.new("http://cu.hgnc.bio2rdf.org/sparql")
+        sparql.query(qry).map(&:official).first.to_s
+      end
+
+      def parse_barcode(code)
+      	#TCGA-E9-A22B-01A-11D-A159-09
+      	[code[5..11], code[13..-1]]
+      end
+
+      def structure(options={})
+
+        str = prefixes(@dataset_name,options)
+        str << data_structure_definition(@measures,@dimensions,@codes,@dataset_name,options)
+        str << dataset(@dataset_name,options)
+        component_specifications(@measures, @dimensions, @codes, @dataset_name, options).map{ |c| str << c }
+        measure_properties(@measures,@dataset_name,options).map{|m| str << m}
+        dimension_properties(@dimensions,@codes, @dataset_name,options).map{|d| str << d}
+        code_lists(@codes,TCGA_CODES,@dataset_name,options).map{|c| str << c}
+        concept_codes(@codes,TCGA_CODES,@dataset_name,options).map{|c| str << c}
+        str
+      end
+
+      def post_process(file)
+        reg = %r{http://identifiers.org/hgnc.symbol/(\w+)}
+        @@hugo_cache ||= {}
+        PubliSci::PostProcessor.process(file,file,reg){|g|
+          @@hugo_cache[g] ||= official_symbol(g)
+         'http://identifiers.org/hgnc.symbol/' + cache[g]
+       }
+      end
+    end
+  end
+end