opentox-ruby 0.0.1 → 0.0.2

data/lib/parser.rb

@@ -0,0 +1,286 @@
+require 'spreadsheet'
+require 'roo'
+
+class String
+
+  # Split RDF statement into triples
+  # @return [Array] Array with [subject,predicate,object]
+  def to_triple
+    self.chomp.split(' ',3).collect{|i| i.sub(/\s+.$/,'').gsub(/[<>"]/,'')}
+  end
+
+end
+
+module OpenTox
+
+  # Parser for various input formats
+  module Parser
+
+    # OWL-DL parser 
+    module Owl
+
+      # Create a new OWL-DL parser
+      # @param uri URI of OpenTox object
+      # @return [OpenTox::Parser::Owl] OWL-DL parser
+      def initialize(uri)
+        @uri = uri
+        @metadata = {}
+      end
+
+      # Read metadata from opentox service
+      # @return [Hash] Object metadata
+      def load_metadata
+
+        if @dataset
+          uri = File.join(@uri,"metadata")
+        else
+          uri = @uri
+        end
+
+        statements = []
+        parameter_ids = []
+        `rapper -i rdfxml -o ntriples #{uri} 2>/dev/null`.each_line do |line|
+          triple = line.to_triple
+          @metadata[triple[1]] = triple[2].split('^^').first if triple[0] == @uri and triple[1] != RDF['type']
+          statements << triple 
+          parameter_ids << triple[2] if triple[1] == OT.parameters
+        end
+        unless parameter_ids.empty?
+          @metadata[OT.parameters] = []
+          parameter_ids.each do |p|
+            parameter = {}
+            statements.each{ |t| parameter[t[1]] = t[2] if t[0] == p and t[1] != RDF['type']}
+            @metadata[OT.parameters] << parameter
+          end
+        end
+        @metadata
+      end
+
+      # Generic parser for all OpenTox classes
+      class Generic
+        include Owl
+      end
+
+      # OWL-DL parser for datasets
+      class Dataset
+
+        include Owl
+
+        attr_writer :uri
+
+        # Create a new OWL-DL dataset parser
+        # @param uri Dataset URI 
+        # @return [OpenTox::Parser::Owl::Dataset] OWL-DL parser
+        def initialize(uri)
+          super uri
+          @dataset = ::OpenTox::Dataset.new(@uri)
+        end
+
+        # Read data from dataset service. Files can be parsed by setting #uri to a filename (after initialization with a real URI)
+        # @example Read data from an external service
+        #   parser = OpenTox::Parser::Owl::Dataaset.new "http://wwbservices.in-silico.ch/dataset/1"
+        #   dataset = parser.load_uri
+        # @example Create dataset from RDF/XML file
+        #   dataset = OpenTox::Dataset.create
+        #   parser = OpenTox::Parser::Owl::Dataaset.new dataset.uri
+        #   parser.uri = "dataset.rdfxml" # insert your input file
+        #   dataset = parser.load_uri
+        #   dataset.save
+        # @return [Hash] Internal dataset representation
+        def load_uri
+          data = {}
+          feature_values = {}
+          feature = {}
+          other_statements = {}
+          `rapper -i rdfxml -o ntriples #{@uri} 2>/dev/null`.each_line do |line|
+            triple = line.chomp.split(' ',3)
+            triple = triple[0..2].collect{|i| i.sub(/\s+.$/,'').gsub(/[<>"]/,'')}
+            case triple[1] 
+            when /#{OT.values}/i
+              data[triple[0]] = {:compound => "", :values => []} unless data[triple[0]]
+              data[triple[0]][:values] << triple[2]  
+            when /#{OT.value}/i
+              feature_values[triple[0]] = triple[2] 
+            when /#{OT.compound}/i
+              data[triple[0]] = {:compound => "", :values => []} unless data[triple[0]]
+              data[triple[0]][:compound] = triple[2]  
+            when /#{OT.feature}/i
+              feature[triple[0]] = triple[2] 
+            else 
+            end
+          end
+          data.each do |id,entry|
+            entry[:values].each do |value_id|
+              value = feature_values[value_id].split(/\^\^/).first # remove XSD.type
+              @dataset.add entry[:compound],feature[value_id],value
+            end
+          end
+          load_features
+          @dataset.metadata = load_metadata
+          @dataset
+        end
+
+        # Read only features from a dataset service. 
+        # @return [Hash] Internal features representation
+        def load_features
+          uri = File.join(@uri,"features")
+          statements = []
+          features = Set.new
+          `rapper -i rdfxml -o ntriples #{uri} 2>/dev/null`.each_line do |line|
+            triple = line.chomp.split('> ').collect{|i| i.sub(/\s+.$/,'').gsub(/[<>"]/,'')}[0..2]
+            statements << triple
+            features << triple[0] if triple[1] == RDF['type'] and triple[2] == OT.Feature
+          end
+          statements.each do |triple|
+            if features.include? triple[0]
+              @dataset.features[triple[0]] = {} unless @dataset.features[triple[0]] 
+              @dataset.features[triple[0]][triple[1]] = triple[2].split('^^').first
+            end
+          end
+          @dataset.features
+        end
+
+      end
+
+    end
+
+    # Parser for getting spreadsheet data into a dataset
+    class Spreadsheets
+
+      attr_accessor :dataset
+
+      def initialize
+        @data = []
+        @features = []
+        @feature_types = {}
+
+        @format_errors = ""
+        @smiles_errors = []
+        @activity_errors = []
+        @duplicates = {}
+      end
+
+      # Load Spreadsheet book (created with roo gem http://roo.rubyforge.org/, excel format specification: http://toxcreate.org/help)
+      # @param [Excel] book Excel workbook object (created with roo gem)
+      # @return [OpenTox::Dataset] Dataset object with Excel data
+      def load_spreadsheet(book)
+        book.default_sheet = 0
+        add_features book.row(1)
+        2.upto(book.last_row) { |i| add_values book.row(i) }
+        warnings
+        @dataset
+      end
+
+      # Load CSV string (format specification: http://toxcreate.org/help)
+      # @param [String] csv CSV representation of the dataset
+      # @return [OpenTox::Dataset] Dataset object with CSV data
+      def load_csv(csv)
+        row = 0
+        input = csv.split("\n")
+        add_features split_row(input.shift)
+        input.each { |row| add_values split_row(row) }
+        warnings
+        @dataset
+      end
+
+      private
+
+      def warnings
+
+        info = ''
+        @feature_types.each do |feature,types|
+          if types.uniq.size > 1
+            type = OT.NumericFeature
+          else
+            type = types.first
+          end
+          @dataset.add_feature_metadata(feature,{OT.isA => type})
+          info += "\"#{@dataset.feature_name(feature)}\" detected as #{type.split('#').last}."
+
+          # TODO: rewrite feature values
+          # TODO if value.to_f == 0 @activity_errors << "#{smiles} Zero values not allowed for regression datasets - entry ignored."
+        end
+
+        @dataset.metadata[OT.Info] = info 
+
+        warnings = ''
+        warnings += "<p>Incorrect Smiles structures (ignored):</p>" + @smiles_errors.join("<br/>") unless @smiles_errors.empty?
+        warnings += "<p>Irregular activities (ignored):</p>" + @activity_errors.join("<br/>") unless @activity_errors.empty?
+        duplicate_warnings = ''
+        @duplicates.each {|inchi,lines| duplicate_warnings << "<p>#{lines.join('<br/>')}</p>" if lines.size > 1 }
+        warnings += "<p>Duplicated structures (all structures/activities used for model building, please  make sure, that the results were obtained from <em>independent</em> experiments):</p>" + duplicate_warnings unless duplicate_warnings.empty?
+
+        @dataset.metadata[OT.Warnings] = warnings 
+
+      end
+
+      def add_features(row)
+        row.shift  # get rid of smiles entry
+        row.each do |feature_name|
+          feature_uri = File.join(@dataset.uri,"feature",URI.encode(feature_name))
+          @feature_types[feature_uri] = []
+          @features << feature_uri
+          @dataset.add_feature(feature_uri,{DC.title => feature_name})
+        end
+      end
+
+      def add_values(row)
+
+        smiles = row.shift
+        compound = Compound.from_smiles(smiles)
+        if compound.nil? or compound.inchi.nil? or compound.inchi == ""
+          @smiles_errors << smiles+", "+row.join(", ") 
+          return false
+        end
+        @duplicates[compound.inchi] = [] unless @duplicates[compound.inchi]
+        @duplicates[compound.inchi] << smiles+", "+row.join(", ")
+
+        row.each_index do |i|
+          value = row[i]
+          feature = @features[i]
+          type = feature_type(value)
+
+          @feature_types[feature] << type 
+
+          case type
+          when OT.NominalFeature
+            case value.to_s
+            when TRUE_REGEXP
+              @dataset.add(compound.uri, feature, true )
+            when FALSE_REGEXP
+              @dataset.add(compound.uri, feature, false )
+            end
+          when OT.NumericFeature
+            @dataset.add compound.uri, feature, value.to_f
+          when OT.StringFeature
+            @dataset.add compound.uri, feature, value.to_s
+            @activity_errors << smiles+", "+row.join(", ")
+          end
+        end
+      end
+
+      def numeric?(value)
+        true if Float(value) rescue false
+      end
+
+      def classification?(value)
+        !value.to_s.strip.match(TRUE_REGEXP).nil? or !value.to_s.strip.match(FALSE_REGEXP).nil?
+      end
+
+      def feature_type(value)
+        if classification? value
+          return OT.NominalFeature
+        elsif numeric? value
+          return OT.NumericFeature
+        else
+          return OT.StringFeature
+        end
+      end
+
+      def split_row(row)
+        row.chomp.gsub(/["']/,'').split(/\s*[,;]\s*/) # remove quotes
+      end
+
+    end
+  end
+end

data/lib/rest_client_wrapper.rb

@@ -1,5 +1,3 @@
-
-
 module OpenTox
 
   #PENDING: implement ot error api, move to own file
@@ -60,14 +58,14 @@ module OpenTox
     def self.execute( rest_call, uri, headers, payload=nil, wait=true )
       
       do_halt 400,"uri is null",uri,headers,payload unless uri
-      do_halt 400,"not a uri",uri,headers,payload unless Utils.is_uri?(uri)
+      do_halt 400,"not a uri",uri,headers,payload unless uri.to_s.uri?
       do_halt 400,"headers are no hash",uri,headers,payload unless headers==nil or headers.is_a?(Hash)
       do_halt 400,"nil headers for post not allowed, use {}",uri,headers,payload if rest_call=="post" and headers==nil
       headers.each{ |k,v| headers.delete(k) if v==nil } if headers #remove keys with empty values, as this can cause problems
       
       begin
         #LOGGER.debug "RestCall: "+rest_call.to_s+" "+uri.to_s+" "+headers.inspect
-        resource = RestClient::Resource.new(uri,{:timeout => 60}) #, :user => @@users[:users].keys[0], :password => @@users[:users].values[0]})
+        resource = RestClient::Resource.new(uri,{:timeout => 60}) 
         if payload
           result = resource.send(rest_call, payload, headers)
         elsif headers
@@ -82,6 +80,7 @@ module OpenTox
         raise "content-type not set" unless res.content_type
         res.code = result.code
         
+        # TODO: Ambit returns task representation with 200 instead of result URI
         return res if res.code==200 || !wait
         
         while (res.code==201 || res.code==202)
@@ -110,12 +109,13 @@ module OpenTox
                           
       task = nil
       case res.content_type
-      when /application\/rdf\+xml|application\/x-yaml/
-        task = OpenTox::Task.from_data(res, res.content_type, res.code, base_uri)
+      when /application\/rdf\+xml/
+        task = OpenTox::Task.from_rdfxml(res)
+      when /yaml/
+        task = OpenTox::Task.from_yaml(res)
       when /text\//
-        raise "uri list has more than one entry, should be a task" if res.content_type=~/text\/uri-list/ and
-          res.split("\n").size > 1 #if uri list contains more then one uri, its not a task
-        task = OpenTox::Task.find(res.to_s) if Utils.task_uri?(res)
+        raise "uri list has more than one entry, should be a task" if res.content_type=~/text\/uri-list/ and res.split("\n").size > 1 #if uri list contains more then one uri, its not a task
+        task = OpenTox::Task.find(res.to_s) if res.to_s.uri?
       else
         raise "unknown content-type for task: '"+res.content_type.to_s+"'" #+"' content: "+res[0..200].to_s
       end
@@ -124,7 +124,7 @@ module OpenTox
       task.wait_for_completion
       raise task.description unless task.completed? # maybe task was cancelled / error
       
-      res = WrapperResult.new task.resultURI
+      res = WrapperResult.new task.result_uri
       res.code = task.http_code
       res.content_type = "text/uri-list"
       return res
@@ -154,8 +154,8 @@ module OpenTox
       # we are either in a task, or in sinatra
       # PENDING: always return yaml for now
       
-      if $self_task #this global var in Task.as_task to mark that the current process is running in a task
-        raise error.to_yaml # the error is caught, logged, and task state is set to error in Task.as_task
+      if $self_task #this global var in Task.create to mark that the current process is running in a task
+        raise error.to_yaml # the error is caught, logged, and task state is set to error in Task.create
       #elsif $sinatra  #else halt sinatra
          #$sinatra.halt(502,error.to_yaml)
       elsif defined?(halt)         

data/lib/serializer.rb

@@ -0,0 +1,340 @@
+require 'spreadsheet'
+require 'yajl'
+
+module OpenTox
+
+  # Serialzer for various oputput formats
+  module Serializer
+
+    # OWL-DL Serializer, modelled according to to http://n2.talis.com/wiki/RDF_JSON_Specification
+    class Owl
+
+      attr_accessor :object
+
+      def initialize
+
+        @object = {
+          # this should come from opntox.owl
+          OT.Compound => { RDF["type"] => [{ "type" => "uri", "value" => OWL['Class'] }] } ,
+          OT.Feature => { RDF["type"] => [{ "type" => "uri", "value" => OWL['Class'] }] } ,
+          OT.NominalFeature => { RDF["type"] => [{ "type" => "uri", "value" => OWL['Class'] }] } ,
+          OT.NumericFeature => { RDF["type"] => [{ "type" => "uri", "value" => OWL['Class'] }] } ,
+          OT.StringFeature => { RDF["type"] => [{ "type" => "uri", "value" => OWL['Class'] }] } ,
+          OT.Dataset => { RDF["type"] => [{ "type" => "uri", "value" => OWL['Class'] }] } ,
+          OT.DataEntry => { RDF["type"] => [{ "type" => "uri", "value" => OWL['Class'] }] } ,
+          OT.FeatureValue => { RDF["type"] => [{ "type" => "uri", "value" => OWL['Class'] }] } ,
+          OT.Algorithm => { RDF["type"] => [{ "type" => "uri", "value" => OWL['Class'] }] } ,
+          OT.Parameter => { RDF["type"] => [{ "type" => "uri", "value" => OWL['Class'] }] } ,
+          OT.Task => { RDF["type"] => [{ "type" => "uri", "value" => OWL['Class'] }] } ,
+
+          OT.compound => { RDF["type"] => [{ "type" => "uri", "value" => OWL.ObjectProperty }] } ,
+          OT.feature => { RDF["type"] => [{ "type" => "uri", "value" => OWL.ObjectProperty }] } ,
+          OT.dataEntry => { RDF["type"] => [{ "type" => "uri", "value" => OWL.ObjectProperty }] } ,
+          OT.acceptValue => { RDF["type"] => [{ "type" => "uri", "value" => OWL.ObjectProperty }] } ,
+          OT.values => { RDF["type"] => [{ "type" => "uri", "value" => OWL.ObjectProperty }] } ,
+          OT.algorithm => { RDF["type"] => [{ "type" => "uri", "value" => OWL.ObjectProperty }] } ,
+          OT.parameters => { RDF["type"] => [{ "type" => "uri", "value" => OWL.ObjectProperty }] } ,
+
+          DC.title => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          DC.identifier => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          DC.contributor => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          DC.creator => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          DC.description => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          DC.date => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.isA => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.Warnings => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          XSD.anyURI => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.hasStatus => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.resultURI => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+          OT.percentageCompleted => { RDF["type"] => [{ "type" => "uri", "value" => OWL.AnnotationProperty }] } ,
+
+          OT.hasSource => { RDF["type"] => [{ "type" => "uri", "value" => OWL.DatatypeProperty }] } ,
+          OT.value => { RDF["type"] => [{ "type" => "uri", "value" => OWL.DatatypeProperty }] } ,
+          OT.paramScope => { RDF["type"] => [{ "type" => "uri", "value" => OWL.DatatypeProperty }] } ,
+          OT.paramValue => { RDF["type"] => [{ "type" => "uri", "value" => OWL.DatatypeProperty }] } ,
+        }
+
+        @data_entries = {}
+        @values_id = 0
+        @parameter_id = 0
+        
+        @classes = Set.new 
+        @object_properties = Set.new
+        @annotation_properties = Set.new
+        @datatype_properties = Set.new
+
+        @objects = Set.new
+      end
+
+      # Add a compound
+      # @param [String] uri Compound URI
+      def add_compound(uri)
+        @object[uri] = { RDF["type"] => [{ "type" => "uri", "value" => OT.Compound }] }
+      end
+
+      # Add a feature
+      # @param [String] uri Feature URI
+      def add_feature(uri,metadata)
+        @object[uri] = { RDF["type"] => [{ "type" => "uri", "value" => OT.Feature }] }
+        add_metadata uri, metadata
+      end
+
+      # Add a dataset
+      # @param [String] uri Dataset URI
+      def add_dataset(dataset)
+
+        @dataset = dataset.uri
+
+        @object[dataset.uri] = { RDF["type"] => [{ "type" => "uri", "value" => OT.Dataset }] }
+
+        add_metadata dataset.uri, dataset.metadata
+
+        dataset.compounds.each { |compound| add_compound compound }
+        
+        dataset.features.each { |feature,metadata| add_feature feature,metadata }
+        
+        dataset.data_entries.each do |compound,entry|
+          entry.each do |feature,values|
+            values.each { |value| add_data_entry compound,feature,value }
+          end
+        end
+
+      end
+
+      # Add a algorithm
+      # @param [String] uri Algorithm URI
+      def add_algorithm(uri,metadata)
+        @object[uri] = { RDF["type"] => [{ "type" => "uri", "value" => OT.Algorithm }] }
+        add_metadata uri, metadata
+      end
+
+      # Add a model
+      # @param [String] uri Model URI
+      def add_model(uri,metadata)
+        @object[uri] = { RDF["type"] => [{ "type" => "uri", "value" => OT.Model }] }
+        add_metadata uri, metadata
+      end
+
+      # Add a task
+      # @param [String] uri Model URI
+      def add_task(uri,metadata)
+        @object[uri] = { RDF["type"] => [{ "type" => "uri", "value" => OT.Task }] }
+        add_metadata uri, metadata
+      end
+
+      # Add metadata
+      # @param [Hash] metadata
+      def add_metadata(uri,metadata)
+        id = 0
+        metadata.each do |u,v|
+          if v.is_a? Array and u == OT.parameters
+            @object[uri][u] = [] unless @object[uri][u]
+            v.each do |value|
+              id+=1
+              genid = "_:genid#{id}"
+              @object[uri][u] << {"type" => "bnode", "value" => genid}
+              @object[genid] = { RDF["type"] => [{ "type" => "uri", "value" => OT.Parameter}] }
+              value.each do |name,entry|
+                @object[genid][name] = [{"type" => type(entry), "value" => entry }]
+              end
+            end
+          else # v.is_a? String
+            @object[uri] = {} unless @object[uri]
+            @object[uri][u] = [{"type" => type(v), "value" => v }]
+          end
+        end
+      end
+
+      # Add a data entry
+      # @param [String] compound Compound URI
+      # @param [String] feature Feature URI
+      # @param [Boolead,Float] value Feature value
+      def add_data_entry(compound,feature,value)
+        add_compound(compound) unless @object[compound]
+        add_feature(feature,{}) unless @object[feature]
+        unless data_entry = @data_entries[compound]
+          data_entry = "_:dataentry#{@data_entries.size}"
+          @data_entries[compound] = data_entry
+          @object[@dataset][OT.dataEntry] = [] unless @object[@dataset][OT.dataEntry]
+          @object[@dataset][OT.dataEntry] << {"type" => "bnode", "value" => data_entry}
+          @object[data_entry] = {
+            RDF["type"] => [{ "type" => "uri", "value" => OT.DataEntry }],
+            OT.compound => [{ "type" => "uri", "value" => compound }],
+            OT.values => [],
+          }
+        end
+        values = "_:values#{@values_id}"
+        @values_id += 1
+        @object[data_entry][OT.values] << {"type" => "bnode", "value" => values}
+        case type(value)
+        when "uri"
+          v = [{ "type" => "uri", "value" => value}]
+        when "literal"
+          v = [{ "type" => "literal", "value" => value, "datatype" => datatype(value) }]
+        else 
+          raise "Illegal type #{type(value)} for #{value}."
+        end
+        @object[values] = {
+          RDF["type"] => [{ "type" => "uri", "value" => OT.FeatureValue }],
+          OT.feature => [{ "type" => "uri", "value" => feature }],
+          OT.value => v
+        }
+        @object[feature][RDF["type"]] << { "type" => "uri", "value" => featuretype(value) }
+      end
+
+      # Serializers
+      
+      # Convert to N-Triples
+      # @return [text/plain] Object OWL-DL in N-Triples format
+      def to_ntriples
+
+        @triples = Set.new
+        @object.each do |s,entry|
+          s = url(s) if type(s) == "uri"
+          entry.each do |p,objects|
+            p = url(p)
+            objects.each do |o|
+              case o["type"] 
+              when "uri"
+                o = url(o["value"])
+              when "literal"
+                o = literal(o["value"],datatype(o["value"]))
+              when "bnode"
+                o = o["value"]
+              end
+              @triples << [s,p,o]
+            end
+          end
+        end
+        @triples.sort.collect{ |s| s.join(' ').concat(" .") }.join("\n")+"\n"
+      end
+
+      # Convert to RDF/XML
+      # @return [text/plain] Object OWL-DL in RDF/XML format
+      def to_rdfxml
+        Tempfile.open("owl-serializer"){|f| f.write(self.to_ntriples); @path = f.path}
+        `rapper -i ntriples -f 'xmlns:ot="#{OT.uri}"' -f 'xmlns:dc="#{DC.uri}"' -f 'xmlns:rdf="#{RDF.uri}"' -f 'xmlns:owl="#{OWL.uri}"' -o rdfxml #{@path} 2>/dev/null`
+      end
+
+      # Convert to JSON as specified in http://n2.talis.com/wiki/RDF_JSON_Specification
+      # (Ambit services use a different JSON representation)
+      # @return [text/plain] Object OWL-DL in JSON format
+      def to_json
+        #rdf_types
+        Yajl::Encoder.encode(@object)
+      end
+
+      # Helpers for type detection
+      private
+
+      def datatype(value)
+        if value.is_a? TrueClass or value.is_a? FalseClass
+          XSD.boolean
+        elsif value.is_a? Float
+          XSD.float
+        else
+          XSD.string
+        end
+      end
+
+      def featuretype(value)
+        if value.is_a? TrueClass or value.is_a? FalseClass
+          datatype = OT.NominalFeature
+        elsif value.is_a? Float
+          datatype = OT.NumericFeature
+        else
+          datatype = OT.StringFeature
+        end
+      end
+
+      def type(value)
+        begin
+          uri = URI.parse(value)
+          if uri.class == URI::HTTP or uri.class == URI::HTTPS
+            "uri"
+          elsif value.match(/^_/)
+            "bnode"
+          else
+            "literal"
+          end
+        rescue
+          "literal"
+        end
+      end
+
+      def literal(value,type)
+        # concat and << are faster string concatination operators than + 
+        '"'.concat(value.to_s).concat('"^^<').concat(type).concat('>')
+      end
+
+      def url(uri)
+        # concat and << are faster string concatination operators than + 
+        '<'.concat(uri).concat('>')
+      end
+
+      def rdf_types
+        @classes.each { |c| @object[c] = { RDF["type"] => [{ "type" => "uri", "value" => OWL['Class'] }] } } 
+        @object_properties.each { |p| @object[p] = { RDF["type"] => [{ "type" => "uri", "value" => OWL['ObjectProperty'] }] } } 
+        @annotation_properties.each { |a| @object[a] = { RDF["type"] => [{ "type" => "uri", "value" => OWL['AnnotationProperty'] }] } } 
+        @datatype_properties.each { |d| @object[d] = { RDF["type"] => [{ "type" => "uri", "value" => OWL['DatatypeProperty'] }] } } 
+      end
+
+    end
+
+    # Serializer for spreadsheet formats
+    class Spreadsheets # to avoid nameclash with Spreadsheet gem
+
+      # Create a new spreadsheet serializer
+      # @param [OpenTox::Dataset] dataset Dataset object
+      def initialize(dataset)
+        @rows = []
+        @rows << ["SMILES"]
+        features = dataset.features.keys
+        @rows.first << features
+        @rows.first.flatten!
+        dataset.data_entries.each do |compound,entries|
+          smiles = Compound.new(compound).to_smiles
+          row = Array.new(@rows.first.size)
+          row[0] = smiles
+          entries.each do |feature, values|
+            i = features.index(feature)+1
+            values.each do |value|
+              if row[i] 
+                row[i] = "#{row[i]} #{value}" # multiple values
+              else
+                row[i] = value 
+              end
+            end
+          end
+          @rows << row
+        end
+      end
+
+      # Convert to CSV string
+      # @return [String] CSV string
+      def to_csv
+        @rows.collect{|r| r.join(", ")}.join("\n")
+      end
+
+      # Convert to spreadsheet workbook
+      # @return [Spreadsheet::Workbook] Workbook object (use the spreadsheet gemc to write a file)
+      def to_spreadsheet
+        Spreadsheet.client_encoding = 'UTF-8'
+        book = Spreadsheet::Workbook.new
+        sheet = book.create_worksheet(:name => '')
+        sheet.column(0).width = 100
+        i = 0
+        @rows.each do |row|
+          row.each do |c|
+            sheet.row(i).push c
+          end
+          i+=1
+        end
+        book
+      end
+
+    end
+
+
+  end
+end