opentox-client 0.0.1pre

data/lib/dataset.rb

@@ -0,0 +1,318 @@
+module OpenTox
+  
+  # Ruby wrapper for OpenTox Dataset Webservices (http://opentox.org/dev/apis/api-1.2/dataset).
+  # TODO: fix API Doc
+  class Dataset 
+
+    #include OpenTox
+
+    #attr_reader :features, :compounds, :data_entries, :metadata
+
+    # Create dataset with optional URI. Does not load data into the dataset - you will need to execute one of the load_* methods to pull data from a service or to insert it from other representations.
+    # @example Create an empty dataset
+    #   dataset = OpenTox::Dataset.new
+    # @example Create an empty dataset with URI
+    #   dataset = OpenTox::Dataset.new("http:://webservices.in-silico/ch/dataset/1")
+    # @param [optional, String] uri Dataset URI
+    # @return [OpenTox::Dataset] Dataset object
+    def initialize(uri=nil,subjectid=nil)
+      super uri, subjectid
+      @features = {}
+      @compounds = []
+      @data_entries = {}
+    end
+
+=begin
+    # Load YAML representation into the dataset
+    # @param [String] yaml YAML representation of the dataset
+    # @return [OpenTox::Dataset] Dataset object with YAML data
+    def self.from_yaml service_uri, yaml, subjectid=nil
+      Dataset.create(service_uri, subjectid).post yaml, :content_type => "application/x-yaml"
+    end
+
+    # Load RDF/XML representation from a file
+    # @param [String] file File with RDF/XML representation of the dataset
+    # @return [OpenTox::Dataset] Dataset object with RDF/XML data
+    def self.from_rdfxml service_uri, rdfxml, subjectid=nil
+      Dataset.create(service_uri, subjectid).post rdfxml, :content_type => "application/rdf+xml"
+    end
+
+    # Load CSV string (format specification: http://toxcreate.org/help)
+    # - loads data_entries, compounds, features
+    # - sets metadata (warnings) for parser errors
+    # - you will have to set remaining metadata manually
+    # @param [String] csv CSV representation of the dataset
+    # @return [OpenTox::Dataset] Dataset object with CSV data
+    def self.from_csv service_uri, csv, subjectid=nil
+      Dataset.from_file(service_uri, csv, subjectid)
+    end
+
+    # Load Spreadsheet book (created with roo gem http://roo.rubyforge.org/, excel format specification: http://toxcreate.org/help)
+    # - loads data_entries, compounds, features
+    # - sets metadata (warnings) for parser errors
+    # - you will have to set remaining metadata manually
+    # @param [Excel] book Excel workbook object (created with roo gem)
+    # @return [OpenTox::Dataset] Dataset object with Excel data
+    def self.from_xls service_uri, xls, subjectid=nil
+      Dataset.create(service_uri, subjectid).post xls, :content_type => "application/vnd.ms-excel"
+    end
+    
+    def self.from_sdf service_uri, sdf, subjectid=nil
+      Dataset.create(service_uri, subjectid).post sdf, :content_type => 'chemical/x-mdl-sdfile'
+    end
+=end
+
+    # Load all data (metadata, data_entries, compounds and features) from URI
+    # TODO: move to opentox-server
+    def data_entries reload=true
+      if reload
+        file = Tempfile.new("ot-rdfxml")
+        file.puts get :accept => "application/rdf+xml"
+        file.close
+        to_delete = file.path
+            
+        data = {}
+        feature_values = {}
+        feature = {}
+        feature_accept_values = {}
+        other_statements = {}
+        `rapper -i rdfxml -o ntriples #{file.path} 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 /#{RDF::OT.values}|#{RDF::OT1.values}/i
+            data[triple[0]] = {:compound => "", :values => []} unless data[triple[0]]
+            data[triple[0]][:values] << triple[2]  
+          when /#{RDF::OT.value}|#{RDF::OT1.value}/i
+            feature_values[triple[0]] = triple[2] 
+          when /#{RDF::OT.compound}|#{RDF::OT1.compound}/i
+            data[triple[0]] = {:compound => "", :values => []} unless data[triple[0]]
+            data[triple[0]][:compound] = triple[2]
+          when /#{RDF::OT.feature}|#{RDF::OT1.feature}/i
+            feature[triple[0]] = triple[2]
+          when /#{RDF.type}/i
+            if triple[2]=~/#{RDF::OT.Compound}|#{RDF::OT1.Compound}/i and !data[triple[0]]
+              data[triple[0]] = {:compound => triple[0], :values => []} 
+            end
+          when /#{RDF::OT.acceptValue}|#{RDF::OT1.acceptValue}/i # acceptValue in ambit datasets is only provided in dataset/<id> no in dataset/<id>/features  
+            feature_accept_values[triple[0]] = [] unless feature_accept_values[triple[0]]
+            feature_accept_values[triple[0]] << triple[2]
+          else 
+          end
+        end
+        File.delete(to_delete) if to_delete
+        data.each do |id,entry|
+          if entry[:values].size==0
+            # no feature values add plain compounds
+            @compounds << entry[:compound] unless @compounds.include? entry[:compound]
+          else
+            entry[:values].each do |value_id|
+              if feature_values[value_id]
+                split = feature_values[value_id].split(/\^\^/)
+                case split[-1]
+                when RDF::XSD.double, RDF::XSD.float 
+                  value = split.first.to_f
+                when RDF::XSD.boolean
+                  value = split.first=~/(?i)true/ ? true : false                
+                else
+                  value = split.first
+                end
+              end
+              @compounds << entry[:compound] unless @compounds.include? entry[:compound]
+              @features[feature[value_id][value_id]] = {}  unless @features[feature[value_id]]
+              @data_entries[entry[:compound].to_s] = {} unless @data_entries[entry[:compound].to_s]
+              @data_entries[entry[:compound].to_s][feature[value_id]] = [] unless @data_entries[entry[:compound]][feature[value_id]]
+              @data_entries[entry[:compound].to_s][feature[value_id]] << value if value!=nil
+            end
+          end
+        end
+        features subjectid
+        #feature_accept_values.each do |feature, values|
+          #self.features[feature][OT.acceptValue] = values
+        #end
+        self.metadata = metadata(subjectid)
+      end
+      @data_entries
+    end
+
+    # Load and return only compound URIs from the dataset service
+    # @return [Array]  Compound URIs in the dataset
+    def compounds reload=true
+      reload ? @compounds = Compound.all(File.join(@uri,"compounds")) : @compounds
+    end
+
+    # Load and return only features from the dataset service
+    # @return [Hash]  Features of the dataset
+    def features reload=true
+      reload ? @features = Feature.all(File.join(@uri,"features")) : @features
+    end
+
+=begin
+    # returns the accept_values of a feature, i.e. the classification domain / all possible feature values 
+    # @param [String] feature the URI of the feature
+    # @return [Array] return array with strings, nil if value is not set (e.g. when feature is numeric)
+    def accept_values(feature)
+      load_features
+      accept_values = features[feature][OT.acceptValue]
+      accept_values.sort if accept_values
+      accept_values
+    end
+
+    # Detect feature type(s) in the dataset
+    # @return [String] `classification", "regression", "mixed" or unknown`
+    def feature_type
+      load_features
+      feature_types = @features.collect{|f,metadata| metadata[RDF.type]}.flatten.uniq
+      if feature_types.include?(OT.NominalFeature)
+        "classification"
+      elsif feature_types.include?(OT.NumericFeature)
+        "regression"
+      else
+        "unknown"
+      end
+    end
+=end
+
+    # Get Excel representation (alias for to_spreadsheet)
+    # @return [Spreadsheet::Workbook] Workbook which can be written with the spreadsheet gem (data_entries only, metadata will will be discarded))
+    def to_xls
+      get :accept => "application/vnd.ms-excel"
+    end
+
+    # Get CSV string representation (data_entries only, metadata will be discarded)
+    # @return [String] CSV representation
+    def to_csv
+      get :accept => "text/csv"
+    end
+
+    def to_sdf
+      get :accept => 'chemical/x-mdl-sdfile'
+    end
+
+
+    # Get OWL-DL in ntriples format
+    # @return [String] N-Triples representation
+    def to_ntriples
+      get :accept => "application/rdf+xml"
+    end
+
+    # Get OWL-DL in RDF/XML format
+    # @return [String] RDF/XML representation
+    def to_rdfxml
+      get :accept => "application/rdf+xml"
+    end
+
+    # Get name (DC.title) of a feature
+    # @param [String] feature Feature URI
+    # @return [String] Feture title
+    def feature_name(feature)
+      features[feature][DC.title]
+    end
+
+    def title
+      metadata[DC.title]
+    end
+
+    # Insert a statement (compound_uri,feature_uri,value)
+    # @example Insert a statement (compound_uri,feature_uri,value)
+    #   dataset.add "http://webservices.in-silico.ch/compound/InChI=1S/C6Cl6/c7-1-2(8)4(10)6(12)5(11)3(1)9", "http://webservices.in-silico.ch/dataset/1/feature/hamster_carcinogenicity", true
+    # @param [String] compound Compound URI
+    # @param [String] feature Compound URI
+    # @param [Boolean,Float] value Feature value
+    def add (compound,feature,value)
+      @compounds << compound unless @compounds.include? compound
+      @features[feature] = {}  unless @features[feature]
+      @data_entries[compound] = {} unless @data_entries[compound]
+      @data_entries[compound][feature] = [] unless @data_entries[compound][feature]
+      @data_entries[compound][feature] << value if value!=nil
+    end
+
+    # Add a feature
+    # @param [String] feature Feature URI
+    # @param [Hash] metadata Hash with feature metadata
+    def add_feature(feature,metadata={})
+      @features[feature] = metadata
+    end
+
+    # Add/modify metadata for a feature
+    # @param [String] feature Feature URI
+    # @param [Hash] metadata Hash with feature metadata
+    def add_feature_metadata(feature,metadata)
+      metadata.each { |k,v| @features[feature][k] = v }
+    end
+    
+    # Add a new compound
+    # @param [String] compound Compound URI
+    def add_compound (compound)
+      @compounds << compound unless @compounds.include? compound
+    end
+    
+    # Creates a new dataset, by splitting the current dataset, i.e. using only a subset of compounds and features
+    # @param [Array] compounds List of compound URIs
+    # @param [Array] features List of feature URIs
+    # @param [Hash] metadata Hash containing the metadata for the new dataset
+    # @param [String] subjectid
+    # @return [OpenTox::Dataset] newly created dataset, already saved
+    def split( compounds, features, metadata)
+      LOGGER.debug "split dataset using "+compounds.size.to_s+"/"+@compounds.size.to_s+" compounds"
+      raise "no new compounds selected" unless compounds and compounds.size>0
+      dataset = OpenTox::Dataset.create(CONFIG[:services]["opentox-dataset"],@subjectid)
+      if features.size==0
+        compounds.each{ |c| dataset.add_compound(c) }
+      else
+        compounds.each do |c|
+          features.each do |f|
+            if @data_entries[c]==nil or @data_entries[c][f]==nil
+              dataset.add(c,f,nil)
+            else
+              @data_entries[c][f].each do |v|
+                dataset.add(c,f,v)
+              end
+            end
+          end
+        end
+      end
+      # set feature metadata in new dataset accordingly (including accept values)      
+      features.each do |f|
+        self.features[f].each do |k,v|
+          dataset.features[f][k] = v
+        end
+      end
+      dataset.add_metadata(metadata)
+      dataset.save
+      dataset
+    end
+
+    # Save dataset at the dataset service 
+    # - creates a new dataset if uri is not set
+    # - overwrites dataset if uri exists
+    # @return [String] Dataset URI
+    def save
+      @compounds.uniq!
+      # create dataset if uri is empty
+      self.uri = RestClientWrapper.post(CONFIG[:services]["opentox-dataset"],{:subjectid => @subjectid}).to_s.chomp unless @uri
+      if (CONFIG[:yaml_hosts].include?(URI.parse(@uri).host))
+        RestClientWrapper.post(@uri,self.to_yaml,{:content_type =>  "application/x-yaml", :subjectid => @subjectid})
+      else
+        s = Serializer::Owl.new
+        s.add_dataset(self)
+        RestClientWrapper.post(@uri, s.to_rdfxml,{:content_type => "application/rdf+xml" , :subjectid => @subjectid})
+      end
+      @uri
+    end
+
+    private
+    # Copy a dataset (rewrites URI)
+    def copy(dataset)
+      @metadata = dataset.metadata
+      @data_entries = dataset.data_entries
+      @compounds = dataset.compounds
+      @features = dataset.features
+      if @uri
+        self.uri = @uri 
+      else
+        @uri = dataset.metadata[XSD.anyURI]
+      end
+    end
+  end
+end

data/lib/error.rb

@@ -0,0 +1,106 @@
+require 'open4'
+
+# add additional fields to Exception class to format errors according to OT-API
+class RuntimeError
+  attr_accessor :http_code, :uri
+  def initialize message, uri=nil
+    super message
+    @uri = uri
+    @http_code ||= 500
+    $logger.error "\n"+self.report.to_turtle
+  end
+
+  def report
+    # TODO: remove kludge for old task services
+    OpenTox::ErrorReport.new(@http_code, self)
+  end
+end
+
+module OpenTox
+
+  class Error < RuntimeError
+    def initialize code, message, uri=nil
+      @http_code = code
+      super message, uri
+    end
+  end
+
+  # OpenTox errors
+  {
+    "BadRequestError" => 400,
+    "NotAuthorizedError" => 401,
+    "NotFoundError" => 404,
+    "LockedError" => 423,
+    "InternalServerError" => 500,
+    "NotImplementedError" => 501,
+    "ServiceUnavailableError" => 503,
+    "TimeOutError" => 504,
+  }.each do |klass,code|
+    # create error classes 
+    c = Class.new Error do
+      define_method :initialize do |message, uri=nil|
+        super code, message, uri
+      end
+    end
+    OpenTox.const_set klass,c
+    
+    # define global methods for raising errors, eg. bad_request_error
+    Object.send(:define_method, klass.underscore.to_sym) do |message|
+      defined?(@uri) ? uri = @uri : uri=nil
+      # TODO: insert uri from sinatra
+      raise c, message, uri
+    end
+  end
+  
+  # Errors received from RestClientWrapper calls
+  class RestCallError < Error
+    attr_accessor :request, :response
+    def initialize request, response, message
+      @request = request
+      @response = response
+      super 502, message, request.url
+    end
+  end
+
+  # TODO: create reports directly from errors, requires modified task service
+  class ErrorReport
+    def initialize http_code, error
+      @http_code = http_code
+      #@report = report#.to_yaml
+      @report = {}
+      @report[RDF::OT.actor] = error.uri
+      @report[RDF::OT.message] = error.message
+      @report[RDF::OT.statusCode] = @http_code 
+      @report[RDF::OT.errorCode] = error.class.to_s
+      @report[RDF::OT.errorDetails] = caller.collect{|line| line unless line =~ /#{File.dirname(__FILE__)}/}.compact.join("\n")
+      @report[RDF::OT.errorDetails] += "REST paramenters:\n#{error.request.args.inspect}" if defined? error.request
+      @report[RDF::OT.message] += "\n" + error.response.body if defined? error.response
+      # TODO fix Error cause
+      #report[RDF::OT.errorCause] = @report if defined?(@report) 
+    end
+
+    # define to_ and self.from_ methods for various rdf formats
+    RDF_FORMATS.each do |format|
+
+      send :define_method, "to_#{format}".to_sym do
+        rdf = RDF::Writer.for(format).buffer do |writer|
+          subject = RDF::Node.new
+          @report.each do |predicate,object|
+            writer << [subject, predicate, object] if object
+          end
+        end
+        rdf
+      end
+
+=begin
+      define_singleton_method "from_#{format}".to_sym do |rdf|
+        report = ErrorReport.new
+        RDF::Reader.for(format).new(rdf) do |reader|
+          reader.each_statement{ |statement| report.rdf << statement }
+        end
+        report
+      end
+=end
+    end
+  end
+end

data/lib/model.rb

@@ -0,0 +1,14 @@
+module OpenTox
+
+  class Model
+
+    # Run a model with parameters
+    # @param [Hash] params Parameters for OpenTox model
+    # @param [optional,OpenTox::Task] waiting_task (can be a OpenTox::Subtask as well), progress is updated accordingly
+    # @return [text/uri-list] Task or resource URI
+    def run params=nil
+      post params, {:accept => 'text/uri-list'}
+    end
+
+  end
+end

data/lib/opentox-client.rb

@@ -0,0 +1,32 @@
+require 'rubygems'
+require "bundler/setup"
+require 'rdf'
+require 'rdf/raptor'
+require "rest-client"
+require 'uri'
+require 'yaml'
+require 'logger'
+
+# define constants and global variables
+#TODO: switch services to 1.2
+RDF::OT =  RDF::Vocabulary.new 'http://www.opentox.org/api/1.2#'
+RDF::OT1 =  RDF::Vocabulary.new 'http://www.opentox.org/api/1.1#'
+RDF::OTA =  RDF::Vocabulary.new 'http://www.opentox.org/algorithmTypes.owl#'
+
+#CLASSES = ["Compound", "Feature", "Dataset", "Algorithm", "Model", "Validation", "Task", "ErrorReport", "Investigation"]
+CLASSES = ["Compound", "Feature", "Dataset", "Algorithm", "Model", "Validation", "Task", "Investigation"]
+RDF_FORMATS = [:rdfxml,:ntriples,:turtle]
+$default_rdf = "application/rdf+xml"
+
+# Regular expressions for parsing classification data
+TRUE_REGEXP = /^(true|active|1|1.0|tox|activating|carcinogen|mutagenic)$/i
+FALSE_REGEXP = /^(false|inactive|0|0.0|low tox|deactivating|non-carcinogen|non-mutagenic)$/i
+
+require File.join(File.dirname(__FILE__),"overwrite.rb")
+require File.join(File.dirname(__FILE__),"error.rb")
+require File.join(File.dirname(__FILE__),"rest-client-wrapper.rb") 
+require File.join(File.dirname(__FILE__),"otlogger.rb") # avoid require conflicts with logger
+require File.join(File.dirname(__FILE__),"opentox.rb")
+require File.join(File.dirname(__FILE__),"task.rb")
+require File.join(File.dirname(__FILE__),"compound.rb")
+#require File.join(File.dirname(__FILE__),"dataset.rb")