opentox-client 0.0.2pre → 1.0.0pre1

data/.gitignore

@@ -1,4 +1,5 @@
+Gemfile.lock
 *.gem
 .bundle
-Gemfile.lock
 pkg/*
+*~

data/ChangeLog

@@ -0,0 +1,2 @@
+v0.0.3 2012-05-07
+* switch from v0.0.2pre to v0.0.3

data/README.markdown

@@ -1,8 +1,23 @@
-opentox-ruby-minimal
+opentox-client
 ====================
 
 Thin Ruby wrapper for the [OpenTox](http://www.opentox.org) REST API 
 
+Libraries:
+
+* {OpenTox::Algorithm} Wrapper for OpenTox Algorithms
+* {OpenTox::Authorization}  Authorization and Authentication
+* {OpenTox::Compound} Compound Library
+* {OpenTox::Dataset} Dataset Library
+* {OpenTox::Error} extends Exception class according the OpenTox API
+* {OpenTox::Model} Model Library
+* {OpenTox} OpenTox Library - general definition of OpenTox objects
+* {OTLogger} OpenTox Logger Extensions
+* {OpenTox::Policies} parse and serialize XML for the openSSO A&A server  
+* {OpenTox::RestClientWrapper} wrapper for the RestClient gem
+* {OpenTox::Task} Task Library
+
+
 Dependencies
 ------------
 

data/Rakefile

@@ -1,11 +1 @@
-require File.join(File.dirname(__FILE__),"lib","opentox-client.rb")
 require "bundler/gem_tasks"
-require 'rake/testtask'
-
-Rake::TestTask.new do |t|
-  t.libs << 'lib'
-  t.libs << 'test'
-  t.test_files = FileList['test/*.rb']
-  t.verbose = true
-end
-

data/VERSION

@@ -0,0 +1 @@
+1.0.0pre1

data/bin/opentox-client-install

@@ -0,0 +1,46 @@
+#!/bin/sh
+
+# Installs Opentox Webservice.
+# Author: Christoph Helma, Andreas Maunz.
+
+SELF=$(basename $0 -install)
+[ "`id -u`" = "0" ] && echo "This script must be run as non-root." 1>&2 && exit 1
+
+# Adjust ruby version here!
+RUBY_NUM_VER="1.9.3-p194"
+
+echo
+echo "Welcome to service installation (<Return> to continue)."
+read delete_me
+
+
+# check wd is root of service
+DIR=`pwd`
+if echo $DIR | grep "$SELF/bin" >/dev/null 2>&1 ; then cd ..; fi
+
+# # # Boot the script
+
+# load base config, helper funs, environment
+OT_CONFIG_DIR="$HOME/.opentox"
+! [ -f "$OT_CONFIG_DIR/config/install/config.sh" ] && echo "config.sh not found." 1>&2 && exit 1 || . $OT_CONFIG_DIR/config/install/config.sh
+! [ -f "$OT_PREFIX/install/utils.sh" ] && echo "utils.sh not found." 1>&2 && exit 1 || . $OT_PREFIX/install/utils.sh
+[ -f $OT_CONFIG_DIR/opentox-ui.sh ] && . $OT_CONFIG_DIR/opentox-ui.sh # should have been done by user already
+RUBY_DIR="$HOME/.rbenv/versions/$RUBY_NUM_VER"
+
+
+# # # Install
+
+check_utils "rbenv find"
+check_log $SELF
+
+# ruby
+install_ruby
+
+# self
+echo
+install_with_bundler
+
+notify
+
+# return to wd
+cd "$DIR"

data/lib/authorization.rb

@@ -5,7 +5,7 @@ module OpenTox
   #@example Authentication
   #  require "opentox-client"
   #  OpenTox::Authorization::AA = "https://opensso.in-silico.ch" #if not set in .opentox/conf/[environment].yaml
-  #  token = OpenTox::Authorization.authenticate("username", "password")
+  #  subjectid = OpenTox::Authorization.authenticate("username", "password")
   #@see http://www.opentox.org/dev/apis/api-1.2/AA OpenTox A&A API 1.2 specification
 
   module Authorization
@@ -65,6 +65,7 @@ module OpenTox
         out = RestClientWrapper.post("#{AA}/auth/authenticate",{:username=>user, :password => pw}).sub("token.id=","").sub("\n","")
         return out
       rescue
+        resource_not_found_error "#{out.inspect}"
         return nil
       end
     end
@@ -87,11 +88,12 @@ module OpenTox
     # @return [Boolean, nil]  returns true, false or nil (if authorization-request fails).
     def self.authorize(uri, action, subjectid)
       return true if !AA
-      begin
-        return true if RestClientWrapper.post("#{AA}/auth/authorize",{:uri => uri, :action => action, :subjectid => subjectid})== "boolean=true\n"
-      rescue
-        return nil
-      end
+      #begin
+      return true if RestClientWrapper.post("#{AA}/auth/authorize",{:uri => uri, :action => action, :subjectid => subjectid})== "boolean=true\n"
+      return false
+      #rescue
+      #  return nil
+      #end
     end
 
     #Checks if a token is a valid token
@@ -101,7 +103,7 @@ module OpenTox
       return true if !AA
       begin
         return true if RestClientWrapper.post("#{AA}/auth/isTokenValid",:tokenid => subjectid) == "boolean=true\n"
-      rescue
+      rescue #do rescue because openSSO throws 401
         return false
       end
       return false

data/lib/compound.rb

@@ -11,6 +11,7 @@ module OpenTox
     # @param [String] smiles Smiles string
     # @return [OpenTox::Compound] Compound
     def self.from_smiles service_uri, smiles, subjectid=nil
+      @smiles = smiles
       Compound.new RestClientWrapper.post(service_uri, smiles, {:content_type => 'chemical/x-daylight-smiles', :subjectid => subjectid})
     end
 
@@ -18,6 +19,7 @@ module OpenTox
     # @param [String] smiles InChI string
     # @return [OpenTox::Compound] Compound
     def self.from_inchi service_uri, inchi, subjectid=nil
+      @inchi = inchi
       Compound.new RestClientWrapper.post(service_uri, inchi, {:content_type => 'chemical/x-inchi', :subjectid => subjectid})
     end
 
@@ -33,60 +35,78 @@ module OpenTox
     #   compound = OpenTox::Compound.from_name("Benzene")
     # @param [String] name name can be also an InChI/InChiKey, CAS number, etc
     # @return [OpenTox::Compound] Compound
+    #
     def self.from_name service_uri, name, subjectid=nil
-      Compound.new RestClientWrapper.post(service_uri, name, {:content_type => 'text/plain', :subjectid => subjectid})
+      @inchi = RestClientWrapper.get File.join(CACTUS_URI,URI.escape(name),"stdinchi")
+      Compound.new RestClientWrapper.post(service_uri, @inchi, {:content_type => 'chemical/x-inchi', :subjectid => subjectid})
     end
 
 		# Get InChI
     # @return [String] InChI string
-		def to_inchi
-      get(:accept => 'chemical/x-inchi').to_s.chomp if @uri
+		def inchi
+      @inchi ||= RestClientWrapper.get(@uri,{},{:accept => 'chemical/x-inchi'}).chomp
+		end
+
+		# Get InChIKey
+    # @return [String] InChI string
+		def inchikey
+      @inchikey ||= RestClientWrapper.get(@uri,{},{:accept => 'chemical/x-inchikey'}).chomp
 		end
 
 		# Get (canonical) smiles
     # @return [String] Smiles string
-		def to_smiles
-      get(:accept => 'chemical/x-daylight-smiles').chomp
+		def smiles
+      @smiles ||= RestClientWrapper.get(@uri,{},{:accept => 'chemical/x-daylight-smiles'}).chomp
 		end
 
     # Get sdf
     # @return [String] SDF string
-		def to_sdf
-      get(:accept => 'chemical/x-mdl-sdfile').chomp
+		def sdf
+      RestClientWrapper.get(@uri,{},{:accept => 'chemical/x-mdl-sdfile'}).chomp
 		end
 
     # Get gif image
     # @return [image/gif] Image data
-		def to_gif
-			get("#{CACTUS_URI}#{to_inchi}/image")
+		def gif
+      RestClientWrapper.get File.join(CACTUS_URI,inchi,"image")
 		end
 
     # Get png image
     # @example
-    #   image = compound.to_png
+    #   image = compound.png
     # @return [image/png] Image data
-		def to_png
-      get(File.join @uri, "image")
+		def png
+      RestClientWrapper.get(File.join @uri, "image")
 		end
 
     # Get URI of compound image
     # @return [String] Compound image URI
-		def to_image_uri
+		def image_uri
       File.join @uri, "image"
 		end
 
     # Get all known compound names. Relies on an external service for name lookups.
     # @example
-    #   names = compound.to_names
+    #   names = compound.names
     # @return [String] Compound names
-		def to_names
-      begin
-        get("#{CACTUS_URI}#{to_inchi}/names").split("\n")
-      rescue
-        "not available"
-      end
+		def names
+      RestClientWrapper.get("#{CACTUS_URI}#{inchi}/names").split("\n")
 		end
 
+    def cid
+      pug_uri = "http://pubchem.ncbi.nlm.nih.gov/rest/pug/"
+      @cid ||= RestClientWrapper.post(File.join(pug_uri, "compound", "inchi", "cids", "TXT"),{:inchi => inchi}).strip
+    end
+
+    def chebi
+    end
+
+    def chemblid
+      # https://www.ebi.ac.uk/chembldb/ws#individualCompoundByInChiKey
+      uri = "http://www.ebi.ac.uk/chemblws/compounds/smiles/#{smiles}.json"
+      @chemblid = JSON.parse(RestClientWrapper.get(uri))["compounds"].first["chemblId"]
+    end
+
 =begin
 		# Match a smarts string
     # @example

data/lib/dataset.rb

@@ -3,27 +3,137 @@ module OpenTox
   # Ruby wrapper for OpenTox Dataset Webservices (http://opentox.org/dev/apis/api-1.2/dataset).
   class Dataset 
 
-    def data_entries
-      # TODO fix for api 1.2
-      data_entries = []
-      pull 
-      @reload = false
-      metadata[RDF::OT1.dataEntry].collect{|data_entry|
-        data_entries << @rdf.to_hash[data_entry]
-      }
-      @reload = true
-      data_entries
+    attr_accessor :features, :compounds, :data_entries
+
+    def initialize uri=nil, subjectid=nil
+      super uri, subjectid
+      @features = []
+      @compounds = []
+      @data_entries = []
+      append RDF.type, RDF::OT.OrderedDataset
+    end
+
+    def upload filename, wait=true
+      uri = RestClientWrapper.put(@uri, {:file => File.new(filename)}, {:subjectid => @subjectid})
+      OpenTox::Task.new(uri).wait if URI.task?(uri) and wait
+    end
+
+    def to_csv
+      CSV.generate do |csv|
+        csv << ["SMILES"] + @features.collect{|f| f.title}
+        @compounds.each_with_index do |c,i|
+          csv << [c.smiles] + @data_entries[i]
+        end
+      end
     end
 
-    def compounds
-      uri = File.join(@uri,"compounds")
-      RestClientWrapper.get(uri,{},{:accept => "text/uri-list", :subjectid => @subjectid}).split("\n").collect{|uri| OpenTox::Compound.new uri}
+    def get
+      super
+      @features = []
+      @compounds = []
+      @data_entries = []
+      query = RDF::Query.new do
+        pattern [:uri, RDF.type, RDF::OT.OrderedDataset]
+      end
+      if query.execute(@rdf).first # ordered dataset
+        query = RDF::Query.new do
+          pattern [:uri, RDF.type, RDF::OT.Compound]
+          pattern [:uri, RDF::OLO.index, :idx]
+        end
+        @compounds = query.execute(@rdf).sort_by{|s| s.idx}.collect{|s| OpenTox::Compound.new s.uri.to_s}
+        query = RDF::Query.new do
+          pattern [:uri, RDF.type, RDF::OT.Feature]
+          pattern [:uri, RDF::OLO.index, :idx]
+        end
+        @features = query.execute(@rdf).sort_by{|s| s.idx}.collect{|s| OpenTox::Feature.new(s.uri.to_s)}
+        numeric_features = @features.collect{|f| f.get; f[RDF.type].include? RDF::OT.NumericFeature}
+        @compounds.each_with_index do |compound,i|
+          query = RDF::Query.new do
+            pattern [:data_entry, RDF::OLO.index, i]
+            pattern [:data_entry, RDF::OT.values, :values]
+            pattern [:values, RDF::OT.feature, :feature]
+            pattern [:feature, RDF::OLO.index, :feature_idx]
+            pattern [:values, RDF::OT.value, :value]
+          end
+          values = query.execute(@rdf).sort_by{|s| s.feature_idx}.collect do |s|
+            (numeric_features[s.feature_idx]  and s.value.to_s != "") ?  s.value.to_s.to_f : s.value.to_s
+          end
+          @data_entries << values.collect{|v| v == "" ? nil : v}
+        end
+      else
+        query = RDF::Query.new do
+          pattern [:uri, RDF.type, RDF::OT.Feature]
+        end
+        @features = query.execute(@rdf).collect{|s| OpenTox::Feature.new(s.uri.to_s)}
+        query = RDF::Query.new do
+          pattern [:data_entry, RDF::OT.compound, :compound]
+        end
+        @compounds = query.execute(@rdf).sort_by{|s| s.data_entry}.collect{|s| OpenTox::Compound.new s.compound.to_s}
+        numeric_features = @features.collect{|f| f.get; f[RDF.type].include? RDF::OT.NumericFeature}
+        @compounds.each do |compound|
+          values = []
+          @features.each_with_index do |feature,i|
+            query = RDF::Query.new do
+              pattern [:data_entry, RDF::OT.compound, RDF::URI.new(compound.uri)]
+              pattern [:data_entry, RDF::OT.values, :values]
+              pattern [:values, RDF::OT.feature, RDF::URI.new(feature.uri)]
+              pattern [:values, RDF::OT.value, :value]
+            end
+            value = query.execute(@rdf).first.value.to_s
+            value = value.to_f if numeric_features[i] and !value.nil?
+            values << value
+          end
+          @data_entries << values
+        end
+      end
     end
 
-    def features
-      uri = File.join(@uri,"features")
-      RestClientWrapper.get(uri,{},{:accept => "text/uri-list", :subjectid => @subjectid}).split("\n").collect{|uri| OpenTox::Feature.new uri}
+    def get_metadata
+      uri = File.join(@uri,"metadata")
+      begin
+        parse_ntriples RestClientWrapper.get(uri,{},{:accept => "text/plain", :subjectid => @subjectid})
+      rescue # fall back to rdfxml
+        parse_rdfxml RestClientWrapper.get(uri,{},{:accept => "application/rdf+xml", :subjectid => @subjectid})
+      end
+      metadata
     end
 
+    def << data_entry
+      compound = data_entry.shift
+      bad_request_error "Dataset features are empty." unless features
+      bad_request_error "data_entry size does not match features size." unless data_entry.size == features.size
+      bad_request_error "First data_entry is not a OpenTox::Compound" unless compound.class == OpenTox::Compound
+      @compounds << compound
+      @data_entries << data_entry
+    end
+
+    RDF_FORMATS.each do |format|
+
+      # redefine rdf serialization methods 
+      send :define_method, "to_#{format}".to_sym do
+        # TODO: check, might affect appending to unordered datasets
+        features.each_with_index do |feature,i|
+          @rdf << [RDF::URI.new(feature.uri), RDF::URI.new(RDF.type), RDF::URI.new(RDF::OT.Feature)] 
+          @rdf << [RDF::URI.new(feature.uri), RDF::URI.new(RDF::OLO.index), RDF::Literal.new(i)] 
+        end
+        compounds.each_with_index do |compound,i|
+          @rdf << [RDF::URI.new(compound.uri), RDF::URI.new(RDF.type), RDF::URI.new(RDF::OT.Compound)]
+          @rdf << [RDF::URI.new(compound.uri), RDF::URI.new(RDF::OLO.index), RDF::Literal.new(i)]
+          data_entry_node = RDF::Node.new
+          @rdf << [RDF::URI.new(@uri), RDF::URI.new(RDF::OT.dataEntry), data_entry_node]
+          @rdf << [data_entry_node, RDF::URI.new(RDF.type), RDF::URI.new(RDF::OT.DataEntry)]
+          @rdf << [data_entry_node, RDF::URI.new(RDF::OLO.index), RDF::Literal.new(i)]
+          @rdf << [data_entry_node, RDF::URI.new(RDF::OT.compound), RDF::URI.new(compound.uri)]
+          data_entries[i].each_with_index do |value,j|
+            value_node = RDF::Node.new
+            @rdf << [data_entry_node, RDF::URI.new(RDF::OT.values), value_node]
+            @rdf << [value_node, RDF::URI.new(RDF::OT.feature), RDF::URI.new(@features[j].uri)]
+            @rdf << [value_node, RDF::URI.new(RDF::OT.value), RDF::Literal.new(value)]
+          end
+        end
+        super()
+      end
+
+    end
   end
 end

data/lib/error.rb

@@ -5,20 +5,51 @@ class RuntimeError
   attr_accessor :http_code, :uri
   def initialize message, uri=nil
     super message
-    @uri = uri
+    @uri = uri.to_s.sub(%r{//.*:.*@},'//') # remove credentials from uri
     @http_code ||= 500
-    $logger.error "\n"+self.report.to_turtle
+    @rdf = RDF::Graph.new
+    subject = RDF::Node.new
+    @rdf << [subject, RDF.type, RDF::OT.ErrorReport]
+    @rdf << [subject, RDF::OT.actor, @uri]
+    @rdf << [subject, RDF::OT.message, message.to_s]
+    @rdf << [subject, RDF::OT.statusCode, @http_code]
+    @rdf << [subject, RDF::OT.errorCode, self.class.to_s]
+    @rdf << [subject, RDF::OT.errorCause, short_backtrace]
+    $logger.error("\n"+self.to_turtle)
   end
 
-  def report
-    # TODO: remove kludge for old task services
-    OpenTox::ErrorReport.new(@http_code, self)
+  def short_backtrace
+    backtrace = caller.collect{|line| line unless line =~ /#{File.dirname(__FILE__)}/}.compact
+    cut_index = backtrace.find_index{|line| line.match /sinatra|minitest/}
+    cut_index ||= backtrace.size
+    cut_index -= 1
+    cut_index = backtrace.size-1 if cut_index < 0
+    backtrace[0..cut_index].join("\n")
   end
+
+  RDF_FORMATS.each do |format|
+    # rdf serialization methods for all formats e.g. to_rdfxml
+    send :define_method, "to_#{format}".to_sym do
+      RDF::Writer.for(format).buffer do |writer|
+        @rdf.each{|statement| writer << statement}
+      end
+    end
+  end
+
+  def to_turtle # redefine to use prefixes (not supported by RDF::Writer)
+    prefixes = {:rdf => "http://www.w3.org/1999/02/22-rdf-syntax-ns#"}
+    ['OT', 'DC', 'XSD', 'OLO'].each{|p| prefixes[p.downcase.to_sym] = eval("RDF::#{p}.to_s") }
+    RDF::N3::Writer.for(:turtle).buffer(:prefixes => prefixes)  do |writer|
+      @rdf.each{|statement| writer << statement}
+    end
+  end
+
 end
 
 module OpenTox
 
   class Error < RuntimeError
+    
     def initialize code, message, uri=nil
       @http_code = code
       super message, uri
@@ -26,92 +57,19 @@ module OpenTox
   end
 
   # OpenTox errors
-  {
-    "BadRequestError" => 400,
-    "NotAuthorizedError" => 401,
-    "NotFoundError" => 404,
-    "LockedError" => 423,
-    "InternalServerError" => 500,
-    "NotImplementedError" => 501,
-    "ServiceUnavailableError" => 503,
-    "TimeOutError" => 504,
-  }.each do |klass,code|
+  RestClientWrapper.known_errors.each do |error|
     # create error classes 
     c = Class.new Error do
       define_method :initialize do |message, uri=nil|
-        super code, message, uri
+        super error[:code], message, uri
       end
     end
-    OpenTox.const_set klass,c
+    OpenTox.const_set error[:class],c
     
     # define global methods for raising errors, eg. bad_request_error
-    Object.send(:define_method, klass.underscore.to_sym) do |message,uri=nil|
-      raise c, message, uri
+    Object.send(:define_method, error[:method]) do |message,uri=nil|
+      raise c.new(message, uri)
     end
   end
   
-  # Errors received from RestClientWrapper calls
-  class RestCallError < Error
-    attr_accessor :request#, :response
-    def initialize message, request, uri
-    #def initialize request, response, message
-      @request = request
-      #@response = response
-      super 502, message, uri
-    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[RDF::OT.actor] = error.uri.to_s
-      @report[RDF::OT.message] = error.message.to_s
-      @report[RDF::OT.statusCode] = @http_code 
-      @report[RDF::OT.errorCode] = error.class.to_s
-
-      # cut backtrace
-      backtrace = caller.collect{|line| line unless line =~ /#{File.dirname(__FILE__)}/}.compact
-      cut_index = backtrace.find_index{|line| line.match /sinatra|minitest/}
-      cut_index ||= backtrace.size
-      cut_index -= 1
-      cut_index = backtrace.size-1 if cut_index < 0
-      @report[RDF::OT.errorDetails] = backtrace[0..cut_index].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.to_s if defined? error.response
-      # TODO fix Error cause
-      # should point to another errorReport, but errorReports do not have URIs
-      # create a separate service?
-      #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|
-          # TODO: not used for turtle
-          # http://rdf.rubyforge.org/RDF/Writer.html#
-          writer.prefix :ot, RDF::URI('http://www.opentox.org/api/1.2#')
-          writer.prefix :ot1_1, RDF::URI('http://www.opentox.org/api/1.1#')
-          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