publisci 0.1.2

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

@@ -0,0 +1,112 @@
+module PubliSci
+  module Readers
+    class RCross
+      include PubliSci::Dataset::DataCube
+      include PubliSci::Readers::Output
+
+      def generate_n3(client, var, outfile_base, options={})
+        meas = measures(client,var,options)
+        dim = dimensions(client,var,options)
+        codes = codes(client,var,options)
+
+        #write structure
+        open(outfile_base+'_structure.ttl','w'){|f| f.write structure(client,var,options)}
+
+        n_individuals = client.eval("length(#{var}$pheno[[1]])").payload.first
+        chromosome_list = (1..19).to_a.map(&:to_s) + ["X"]
+        chromosome_list.map{|chrom|
+          open(outfile_base+"_#{chrom}.ttl",'w'){|f| f.write prefixes(var,options)}
+          entries_per_individual = client.eval("length(#{var}$geno$'#{chrom}'$map)").to_ruby
+
+          #get genotype data (currently only for chromosome 1)
+          geno_chr = client.eval("#{var}$geno$'#{chrom}'")
+
+          #get number of markers per individual
+
+          #write observations
+          n_individuals.times{|indi|
+            obs_data = observation_data(client,var,chrom.to_s,indi,geno_chr,entries_per_individual,options)
+            labels = labels_for(obs_data,chrom.to_s,indi)
+            open(outfile_base+"_#{chrom}.ttl",'a'){|f| observations(meas,dim,codes,obs_data,labels,var,options).map{|obs| f.write obs}}
+            puts "(#{chrom}) #{indi}/#{n_individuals}" unless options[:quiet]
+          }
+        }
+
+      end
+
+      def structure(client,var,options={})
+        meas = measures(client,var,options)
+        dim = dimensions(client,var,options)
+        codes = codes(client,var,options)
+
+        str = prefixes(var,options)
+        str << data_structure_definition(meas,dim,codes,var,options)
+        str << dataset(var,options)
+        component_specifications(meas, dim, codes, var, options).map{ |c| str << c }
+        measure_properties(meas,var,options).map{|m| str << m}
+
+        str
+      end
+
+      def measures(client, var, options={})
+        pheno_names = client.eval("names(#{var}$pheno)").to_ruby
+        if options[:measures]
+          (pheno_names & options[:measures]) | ["genotype","markerpos","marker"]
+        else
+          pheno_names | ["genotype","markerpos","marker"]
+        end
+        # measure_properties(measures,var,options)
+      end
+
+      def dimensions(client, var, options={})
+        # dimension_properties([""],var)
+        []
+      end
+
+      def codes(client, var, options={})
+        []
+      end
+
+      def labels_for(data,chr,individual,options={})
+        labels=(((data.first.last.size*individual)+1)..(data.first.last.size*(individual+1))).to_a.map(&:to_s)
+        labels.map{|l| l.insert(0,"#{chr}_")}
+        labels
+      end
+
+      def observation_data(client, var, chr, row_individ, geno_chr, entries_per_individual, options={})
+        data = {}
+
+        data["chr"] = []
+        data["genotype"] = []
+        data["individual"] = []
+        data["marker"] = []
+        data["markerpos"] = []
+
+        pheno_names = client.eval("names(#{var}$pheno)").to_ruby
+        pheno_names.map{|name|
+          data[name] = []
+        }
+        data["individual"] << (1..entries_per_individual).to_a.fill(row_individ)
+
+        pheno_names.map{|name|
+          data[name] << (1..entries_per_individual).to_a.fill(client.eval("#{var}$pheno$#{name}").to_ruby[row_individ])
+        }
+
+        num_markers = geno_chr.payload.first.to_ruby.column_size
+        data["chr"] << (1..num_markers).to_a.fill(chr)
+        data["genotype"] << geno_chr.payload["data"].to_ruby.row(row_individ).to_a
+        data["marker"] << client.eval("names(#{var}$geno$'#{chr}'$map)").payload
+        data["markerpos"] << geno_chr.payload["map"].to_a
+
+        data.map{|k,v| v.flatten!}
+        data
+      end
+
+      def num_individuals(client, var, options={})
+        client.eval("#{var}$pheno").payload.first.to_ruby.size
+      end
+
+
+    end
+  end
+end

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

@@ -0,0 +1,176 @@
+module PubliSci
+	module Readers
+		class RMatrix
+			include PubliSci::Dataset::DataCube
+
+			#NOTE; this is pretty much hard coded for Karl's application right now, and doesn't
+			# do any dimension or code generation. Since its a set of LOD scores indexed by dimension
+			# and marker the usual datacube generator wont work (I think). In the future adding an option
+			# to specify this kind of a dataset would probably be useful
+
+
+			def generate_n3(client, var, outfile_base, options={})
+				meas = measures(client,var,options)
+				dim = dimensions(client,var,options)
+				codes = codes(client,var,options)
+
+				outvar = sanitize([var]).first
+
+				probes_per_file = options[:probes_per_file] || 100
+				col_select = "colnames"
+				col_select = "names" if options[:type] == :dataframe
+
+				#write structure
+				open(outfile_base+'_structure.ttl','w'){|f| f.write structure(client,var,outvar,options)}
+
+				probes=client.eval("#{col_select}(#{var})").to_ruby
+				if probes == nil
+					client.eval("colnames(#{var})=1:ncol(#{var})")
+					probes=client.eval("#{col_select}(#{var})").to_ruby
+				end
+				markers = rows(client,var,options)
+
+        if options[:print]
+            puts prefixes(var,options)
+        end
+
+        if options[:output] == :string
+            str = prefixes(var,options)
+        end
+
+				probes.each_with_index{|probe,i|
+					#write prefixes and erase old file on first run
+          unless options[:print] || options[:output] == :string
+  					open(outfile_base+"_#{i/probes_per_file}.ttl",'w'){|f| f.write prefixes(var,options)} if i % probes_per_file == 0
+          end
+					i+=1
+					obs_data = observation_data(client,var,i,markers,options)
+					labels = labels_for(client,var,probe)
+
+					# labels = sanitize(labels)
+					# return obs_data
+          if options[:print]
+            observations(meas,dim,codes,obs_data,labels,outvar,options).each{|obs| puts obs}
+          end
+
+          if options[:output] == :string
+            observations(meas,dim,codes,obs_data,labels,outvar,options).each{|obs| str << obs}
+          end
+
+          unless options[:print] || options[:output] == :string
+  					open(outfile_base+"_#{i/probes_per_file}.ttl",'a'){|f| observations(meas,dim,codes,obs_data,labels,outvar,options).map{|obs| f.write obs}}
+  					puts "#{i}/#{probes.size}" unless options[:quiet]
+          end
+				}
+
+        if options[:output] == :string
+          str
+        end
+			end
+
+			def structure(client,var,outvar,options={})
+				meas = measures(client,var,options)
+				dim = dimensions(client,var,options)
+				codes = codes(client,var,options)
+
+				str = prefixes(var, options)
+				str << data_structure_definition(meas,[],codes,outvar,options)
+				str << dataset(outvar,options)
+    		component_specifications(meas, dim, codes, var, options).map{ |c| str << c }
+				measure_properties(meas,var,options).map{|m| str << m}
+
+				str
+			end
+
+			#for now just make everything a measure
+			def measures(client, var, options={})
+				if options[:measures]
+						options[:measures]
+				else
+					["probe","marker","value"]
+				end
+				# measure_properties(measures,var,options)
+			end
+
+			def dimensions(client, var, options={})
+				# dimension_properties([""],var)
+				[]
+			end
+
+			def codes(client, var, options={})
+				[]
+			end
+
+			def labels_for(connection,var,probe_id,options={})
+				row_names = connection.eval("row.names(#{var})")
+				# row_names = (1..@rexp.payload.first.to_ruby.size).to_a unless row_names.first
+				if row_names == connection.eval('NULL')
+					row_names = (1..connection.eval("nrow(#{var})").payload.first).to_a
+				else
+					row_names = row_names.payload
+				end
+
+	      labels = (1..(row_names.size)).to_a.map(&:to_s)
+	      labels = labels.map{|l|
+	      	l.insert(0,probe_id.to_s + "_")
+	      }
+
+	      labels
+			end
+
+			def rows(connection,var,options={})
+				row_names = connection.eval("row.names(#{var})")
+				#hacky solution because rserve client's .to_ruby method doesn't fully work
+				if row_names == connection.eval('NULL')
+					row_names = (1..connection.eval("nrow(#{var})").payload.first).to_a
+				else
+					row_names = row_names.payload
+				end
+	      row_names
+			end
+
+			def observation_data(client, var, probe_number, row_names, options={})
+
+				data = {}
+				# geno_chr = client.eval("#{var}$geno$'#{chr}'")
+				# n_individuals = client.eval("#{var}$pheno[[1]]").to_ruby.size
+				# entries_per_individual = @rexp.payload["geno"].payload[row_individ].payload["map"].payload.size * @rexp.payload["geno"].payload.names.size
+				col_label = "probe"
+				row_label = "marker"
+				val_label = "value"
+
+				if options[:measures]
+					col_label = options[:measures][0] || "probe"
+					row_label = options[:measures][1] || "marker"
+					val_label = options[:measures][2] || "value"
+				end
+
+				data["#{col_label}"] = []
+				data["#{row_label}"] = []
+				data["#{val_label}"] = []
+
+				# n_individuals.times{|row_individ|
+					# puts "#{row_individ}/#{n_individuals}"
+
+				col_select = "colnames"
+				col_select = "names" if options[:type] == :dataframe
+
+				if options[:type] == :dataframe
+					probe_obj = client.eval("#{var}[[#{probe_number}]]").to_ruby
+				else
+					probe_obj = client.eval("#{var}[,#{probe_number}]").to_ruby
+				end
+				# puts probe_obj
+				probe_id = client.eval("#{col_select}(#{var})[[#{probe_number}]]").to_ruby
+				data["#{col_label}"] = (1..(probe_obj.size)).to_a.fill(probe_id)
+				probe_obj.each_with_index{|lod,i|
+					data["#{row_label}"] << row_names[i]
+					data["#{val_label}"] << lod
+				}
+
+				data.map{|k,v| v.flatten!}
+				data
+			end
+		end
+	end
+end

data/lib/bio-publisci/store.rb

@@ -0,0 +1,56 @@
+module PubliSci
+  # handles connection and messaging to/from the triple store
+  class Store
+    include PubliSci::Query
+
+    def defaults
+      {
+        type: :fourstore,
+        url: "http://localhost:8080", #TODO port etc should eventually be extracted from URI if given
+        replace: false
+      }
+    end
+
+    def add(file,graph)
+      if @options[:type] == :graph
+        throw "please provide an RDF::Repository" unless graph.is_a? RDF::Repository
+        graph.load(file)
+        @store = graph
+        @store
+      elsif @options[:type] == :fourstore
+        if @options[:replace]
+          `curl -T #{file} -H 'Content-Type: application/x-turtle' #{@options[:url]}/data/http%3A%2F%2Frqtl.org%2F#{graph}`
+        else
+          `curl --data-urlencode data@#{file} -d 'graph=http%3A%2F%2Frqtl.org%2F#{graph}' -d 'mime-type=application/x-turtle' #{@options[:url]}/data/`
+        end
+      end
+    end
+
+    def add_all(dir, graph, pattern=nil)
+      pattern = /.+\.ttl/ if pattern == :turtle || pattern == :ttl
+
+      files = Dir.entries(dir) - %w(. ..)
+      files = files.grep(pattern) if pattern.is_a? Regexp
+      nfiles = files.size
+      n = 0
+      files.each{|file| puts file + " #{n+=1}/#{nfiles} files"; puts add(file,graph)}
+    end
+
+    def initialize(options={})
+      @options = defaults.merge(options)
+    end
+
+    def query(string)
+      # execute(string, )
+      if @options[:type] == :graph
+        execute(string, @store, :graph)
+      elsif @options[:type] == :fourstore
+        execute(string, @options[:url], :fourstore)
+      end
+    end
+
+    def url
+      @options[:url]
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+module PubliSci
+  module Writers
+    class ARFF < Base
+      # include PubliSci::Query
+      # include PubliSci::Parser
+      # include PubliSci::Analyzer
+
+      def build_arff(relation, attributes, data, source)
+        str = <<-EOS
+% 1. Title: #{relation.capitalize} Database
+%
+% 2. Sources:
+%    (a) Generated from RDF source #{source}
+%
+@RELATION #{relation}
+
+EOS
+
+        Hash[attributes.sort].map{|attribute,type|
+          str << "@ATTRIBUTE #{attribute} #{type}\n"
+        }
+
+        str << "\n@DATA\n"
+        data.map { |d| str << Hash[d[1].sort].values.join(',') + "\n" }
+
+        str
+      end
+
+      def from_turtle(turtle_file, verbose=false)
+        puts "loading #{turtle_file}" if verbose
+        repo = RDF::Repository.load(turtle_file)
+        puts "loaded #{repo.size} statements into temporary repo" if verbose
+
+        dims = dimensions(repo)
+        meas = measures(repo)
+        data = observations(repo)
+
+        relation = dataSet(repo)
+        codes = codes(repo)
+
+        attributes = {}
+
+        (dims | meas).map{|component|
+          attributes[component] = case recommend_range(data.map{|o| o[1][component]})
+            when "xsd:int"
+              "integer"
+            when "xsd:double"
+              "real"
+            when :coded
+              if dims.include? component
+                "{#{codes[component].join(', ')}}"
+              else
+                "string"
+              end
+            end
+        }
+
+        build_arff(relation, attributes, data, turtle_file)
+      end
+
+      def from_store(repo, dataset=nil, title=nil, verbose=false)
+        # data = observation_hash(execute_from_file("observations.rq",repo,:graph,{"%{dataSet}"=>"<#{dataSet}>"}), true)
+
+        dims = dimensions(repo,dataset)
+        meas = measures(repo,dataset)
+        data = observations(repo,dataset)
+        codes = codes(repo,dataset)
+        attributes = {}
+
+        (dims | meas).map{|component|
+          attributes[component] = case recommend_range(data.map{|o| o[1][component]})
+            when "xsd:int"
+              "integer"
+            when "xsd:double"
+              "real"
+            when :coded
+              if dims.include? component
+                "{#{codes[component].join(', ')}}"
+              else
+                "string"
+              end
+            end
+        }
+
+        dataset = dataSet(repo) unless dataset
+        title = dataset unless title
+        build_arff(title,attributes,data,dataset)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+module PubliSci
+  module Writers
+    class Base
+      include PubliSci::Query
+      include PubliSci::Parser
+      include PubliSci::Analyzer
+
+      def handle_input(input)
+        if input.is_a? String
+          if File.exist? input
+            RDF::Repository.load(input)
+          else
+            raise "UnkownStringInput: #{input}"
+          end
+        elsif input.is_a? RDF::Repository
+          input
+        else
+          raise "UnkownInput: #{input}, #{input.class}"
+        end
+      end
+
+      def dimensions(input, data_set=nil, select=:label)
+        repo = handle_input(input)
+
+        if data_set
+          dims = execute_from_file("dimensions.rq",repo,:graph,{"?dataSet"=>"<#{data_set}>"})
+        else
+          dims = execute_from_file("dimensions.rq",repo,:graph)
+        end
+
+        dims.to_h.map{|d| d[select].to_s}
+      end
+
+      def measures(input, data_set=nil, select=:label)
+        repo = handle_input(input)
+
+        if data_set
+          meas = execute_from_file("measures.rq",repo,:graph,{"?dataSet"=>"<#{data_set}>"})
+        else
+          meas = execute_from_file("measures.rq",repo,:graph)
+        end
+
+        meas.to_h.map{|d| d[select].to_s}
+      end
+
+      def observations(input, data_set = nil, shorten_url = true)
+        repo = handle_input(input)
+
+        if data_set
+          obs = execute_from_file("observations.rq",repo,:graph,{"?dataSet"=>"<#{data_set}>"})
+        else
+          obs = execute_from_file("observations.rq",repo,:graph)
+        end
+
+        observation_hash(obs,shorten_url)
+      end
+
+      def dataSet(input, select = :label)
+        repo = handle_input(input)
+
+        execute_from_file("dataset.rq",repo,:graph).to_h.first[select].to_s
+      end
+
+      def codes(input, data_set = nil, select = :label)
+        repo = handle_input(input)
+
+        if data_set
+          codes = execute_from_file("codes.rq",repo,:graph,{"?dataSet"=>"<#{data_set}>"}).to_h
+        else
+          codes = execute_from_file("codes.rq",repo,:graph).to_h
+        end
+        codes.map{|c| c.values.map(&:to_s)}.inject({}){|h,el|
+          (h[el.first]||=[]) << el.last; h
+        }
+      end
+
+      def turtle_to_ruby(turtle_file, select_dataset=nil, shorten_url=true)
+        repo = RDF::Repository.load(turtle_file)
+
+        repo_to_ruby(repo,select_dataset,shorten_url)
+      end
+
+      def repo_to_ruby(repo,select_dataset=nil, shorten_url=true)
+        select_dataset = dataSet(repo,:dataset) unless select_dataset
+        dims = dimensions(repo,select_dataset)
+        meas = measures(repo,select_dataset)
+        codes = codes(repo,select_dataset)
+        data = observations(repo,select_dataset,shorten_url)
+        {measures: meas, dimensions: dims, coded_dimensions: codes, data: data}
+      end
+    end
+  end
+end