opentox-ruby-api-wrapper 1.4.0 → 1.5.0

data/Rakefile

@@ -10,10 +10,10 @@ begin
     gem.email = "helma@in-silico.ch"
     gem.homepage = "http://github.com/helma/opentox-ruby-api-wrapper"
     gem.authors = ["Christoph Helma"]
-		["sinatra", "rest-client", "rack", "rack-contrib", "rack-flash", "emk-sinatra-url-for", "cehoffman-sinatra-respond_to", "dm-more", "dm-core", "sinatra-static-assets"].each do |dep|
+		["sinatra", "rest-client", "rack", "rack-contrib", "rack-flash", "emk-sinatra-url-for", "sinatra-respond_to", "dm-more", "dm-core", "sinatra-static-assets","tmail"].each do |dep|
 			gem.add_dependency dep
 		end
-		['cucumber','jeweler', "thin"].each do |dep|
+		['cucumber','jeweler'].each do |dep|
 			gem.add_development_dependency dep
 		end
 		gem.files =  FileList["[A-Z]*", "{bin,generators,lib,test}/**/*", 'lib/jeweler/templates/.gitignore']

data/VERSION

@@ -1 +1 @@
-1.4.0
+1.5.0

data/bin/opentox-install-ubuntu.sh

@@ -90,9 +90,9 @@ sudo apt-get install postgresql-server-dev-8.4 | tee -a $INSTALLLOG
 #echo "Installing gems jeweler sinatra emk-sinatra-url-for dm-core cehoffman-sinatra-respond_to rest-client rack-contrib thin cucumber datamapper data_objects do_sqlite3 rinruby"
 sudo gem install jeweler  | tee -a $INSTALLLOG
 sudo gem install sinatra | tee -a $INSTALLLOG
-sudo gem install emk-sinatra-url-for -s http://gems.github.com  | tee -a $INSTALLLOG
+sudo gem install sinatra-url-for | tee -a $INSTALLLOG
 sudo gem install dm-core  | tee -a $INSTALLLOG
-sudo gem install cehoffman-sinatra-respond_to -s http://gems.github.com  | tee -a $INSTALLLOG
+sudo gem install sinatra-respond_to | tee -a $INSTALLLOG
 sudo gem install rest-client | tee -a $INSTALLLOG
 sudo gem install rack-contrib | tee -a $INSTALLLOG
 sudo gem install thin | tee -a $INSTALLLOG

data/bin/yaml2owl.rb

@@ -5,7 +5,7 @@ require 'opentox-ruby-api-wrapper'
 input = YAML.load_file(ARGV[0])
 dataset = OpenTox::Dataset.new
 dataset.title = input[:title]
-dataset.source = input[:source]
+dataset.creator = input[:source]
 input[:data].each do |c,f|
 	f.each do |k,v|
 		v.each do |value|

data/lib/algorithm.rb

@@ -21,8 +21,11 @@ module OpenTox
 			def self.create_model(params)
 				LOGGER.debug params
 				LOGGER.debug File.basename(__FILE__) + ": creating model"
+				LOGGER.debug File.join(@@config[:services]["opentox-algorithm"], "lazar")
+        #resource = RestClient::Resource.new(File.join(@@config[:services]["opentox-algorithm"], "lazar"), :user => @@users[:users].keys[0], :password => @@users[:users].values[0], :content_type => "application/x-yaml")
         resource = RestClient::Resource.new(File.join(@@config[:services]["opentox-algorithm"], "lazar"), :user => @@users[:users].keys[0], :password => @@users[:users].values[0], :content_type => "application/x-yaml")
-        @uri = resource.post(:dataset_uri => params[:dataset_uri], :feature_uri => params[:feature_uri], :feature_generation_uri => File.join(@@config[:services]["opentox-algorithm"], "fminer")).chomp
+        #@uri = resource.post(:dataset_uri => params[:dataset_uri], :feature_uri => params[:feature_uri], :feature_generation_uri => File.join(@@config[:services]["opentox-algorithm"], "fminer")).chomp
+        @uri = resource.post(:dataset_uri => params[:dataset_uri], :prediction_feature => params[:prediction_feature], :feature_generation_uri => File.join(@@config[:services]["opentox-algorithm"], "fminer")).body.chomp
 			end
 
 			def self.uri

data/lib/compound.rb

@@ -18,18 +18,18 @@ module OpenTox
 				@uri = File.join(@@config[:services]["opentox-compound"],URI.escape(@inchi))
 			elsif params[:name]
 				# paranoid URI encoding to keep SMILES charges and brackets
-				@inchi = RestClient.get("#{@@cactus_uri}#{URI.encode(params[:name], Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))}/stdinchi").chomp
+				@inchi = RestClientWrapper.get("#{@@cactus_uri}#{URI.encode(params[:name], Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))}/stdinchi").chomp
 				@uri = File.join(@@config[:services]["opentox-compound"],URI.escape(@inchi))
 			elsif params[:uri]
 				@uri = params[:uri]
 				case params[:uri]
 				when /ambit/ # Ambit does not deliver InChIs reliably
-					smiles = RestClient.get @uri, :accept => 'chemical/x-daylight-smiles'
+					smiles = RestClientWrapper.get @uri, :accept => 'chemical/x-daylight-smiles'
 					@inchi = obconversion(smiles,'smi','inchi')
 				when /InChI/ # shortcut for IST services
 					@inchi = params[:uri].sub(/^.*InChI/, 'InChI')
 				else
-					@inchi = RestClient.get @uri, :accept => 'chemical/x-inchi'
+					@inchi = RestClientWrapper.get @uri, :accept => 'chemical/x-inchi'
 				end
 			end
 		end
@@ -44,7 +44,7 @@ module OpenTox
 		end
 
 		def image
-			RestClient.get("#{@@cactus_uri}#{@inchi}/image")
+			RestClientWrapper.get("#{@@cactus_uri}#{@inchi}/image")
 		end
 
 		def image_uri

data/lib/config/config_ru.rb

@@ -18,3 +18,11 @@ set :raise_errors, true
 end
  
 use Rack::ShowExceptions
+#if MAIL
+#	use Rack::MailExceptions do |mail|
+#			mail.to 'helma@in-silico.ch'
+#			mail.subject '[ERROR] %s'
+#			mail.from "toxcreate@in-silico.ch"
+#			mail.smtp MAIL
+#	end 
+#end

data/lib/dataset.rb

@@ -1,10 +1,10 @@
 LOGGER.progname = File.expand_path(__FILE__)
 
 module OpenTox
-
+  
 	class Dataset 
 
-		attr_accessor :uri, :title, :source, :identifier, :data, :features, :compounds
+		attr_accessor :uri, :title, :creator, :data, :features, :compounds
 
 		def initialize 
 			@data = {}
@@ -12,171 +12,175 @@ module OpenTox
 			@compounds = []
 		end
 
-		def self.find(uri)
-			YAML.load RestClient.get(uri, :accept => 'application/x-yaml').to_s 
+		def self.find(uri, accept_header=nil) 
+    
+      unless accept_header
+        #if uri.match(@@config[:services]["opentox-dataset"]) || uri=~ /188.40.32.88/ || uri =~ /informatik/
+        if !@@config[:accept_headers]["opentox-dataset"].grep(/yaml/).empty?
+          accept_header = 'application/x-yaml'
+        else
+          accept_header = "application/rdf+xml"
+        end
+      end
+      
+      case accept_header
+      when "application/x-yaml"
+				d = YAML.load RestClientWrapper.get(uri.to_s.strip, :accept => 'application/x-yaml').to_s 
+        d.uri = uri unless d.uri
+			when "application/rdf+xml"
+				owl = OpenTox::Owl.from_uri(uri.to_s.strip, "Dataset")
+        
+        d = Dataset.new
+				d.title = owl.get("title")
+				d.creator = owl.get("creator")
+				d.uri = owl.uri
+        
+        # when loading a dataset from owl, only compound- and feature-uris are loaded 
+        owl.load_dataset(d.compounds, d.features)
+				# all features are marked as dirty, loaded dynamically later
+        d.init_dirty_features(owl)
+        
+        d.compounds.uniq!
+        d.features.uniq!
+      else
+        raise "cannot get datset with accept header: "+accept_header.to_s
+		  end
+      return d
 		end
+    
+    # creates a new dataset, using only those compounsd specified in new_compounds
+    # returns uri of new dataset
+    def create_new_dataset( new_compounds, new_features, new_title, new_creator )
+      
+      raise "no new compounds selected" unless new_compounds and new_compounds.size>0
+      
+      # load require features 
+      if ((defined? @dirty_features) && (@dirty_features - new_features).size > 0)
+        (@dirty_features - new_features).each{|f| load_feature_values(f)}
+      end
+      
+      dataset = OpenTox::Dataset.new
+      dataset.title = new_title
+      dataset.creator = new_creator
+      dataset.features = new_features
+      dataset.compounds = new_compounds
+      
+      # Copy dataset data for compounds and features
+      # PENDING: why storing feature values in an array? 
+      new_compounds.each do |c|
+        data_c = []
+        @data[c].each do |d|
+          m = {}
+          new_features.each do |f|
+            m[f] = d[f]
+          end
+          data_c << m 
+        end
+        
+        dataset.data[c] = data_c
+      end
+      return dataset.save
+    end
+    
+    # returns classification value
+    def get_predicted_class(compound, feature)
+      v = get_value(compound, feature)
+      if v.is_a?(Hash)
+        if v.has_key?(:classification)
+          return v[:classification]
+        else
+          return "no classification key"
+        end
+      else
+        raise "predicted class value is not a hash\n"+
+          "value "+v.to_s+"\n"+
+          "value-class "+v.class.to_s+"\n"+
+          "dataset "+@uri.to_s+"\n"+
+          "compound "+compound.to_s+"\n"+
+          "feature "+feature.to_s+"\n"
+      end
+      
+    end
+    
+    # returns prediction confidence if available
+    def get_prediction_confidence(compound, feature)
+      v = get_value(compound, feature)
+      if v.is_a?(Hash)
+        if v.has_key?(:confidence)
+          return v[:confidence].abs
+        else
+          # PENDING: return nil isntead of raising an exception
+          raise "no confidence key"
+        end
+      else
+        raise "prediction confidence value is not a hash value\n"+
+          "value "+v.to_s+"\n"+
+          "value-class "+v.class.to_s+"\n"+
+          "dataset "+@uri.to_s+"\n"+
+          "compound "+compound.to_s+"\n"+
+          "feature "+feature.to_s+"\n"
+      end
+    end
+    
+    # return compound-feature value
+    def get_value(compound, feature)
+      if (defined? @dirty_features) && @dirty_features.include?(feature)
+        load_feature_values(feature)
+      end
+      
+      v = @data[compound]
+      raise "no values for compound "+compound.to_s if v==nil
+      if v.is_a?(Array)
+        # PENDING: why using an array here?
+        v.each do |e|
+          if e.is_a?(Hash)
+            if e.has_key?(feature)
+              return e[feature]
+            end
+          else
+            raise "invalid internal value type"
+          end
+        end
+        raise "feature value no found: "+feature.to_s
+      else
+        raise "value is not an array\n"+
+              "value "+v.to_s+"\n"+
+              "value-class "+v.class.to_s+"\n"+
+              "dataset "+@uri.to_s+"\n"+
+              "compound "+compound.to_s+"\n"+
+              "feature "+feature.to_s+"\n"
+      end
+    end
 
+    # loads specified feature and removes dirty-flag, loads all features if feature is nil
+    def load_feature_values(feature=nil)
+      if feature
+        raise "feature already loaded" unless @dirty_features.include?(feature)
+        @owl.load_dataset_feature_values(@compounds, @data, feature)
+        @dirty_features.delete(feature)
+      else
+        @data = {}
+        @owl.load_dataset_feature_values(@compounds, @data)
+        @dirty_features.clear
+      end
+    end
 
 		def save
+      # loads all features before loading  
+      if ((defined? @dirty_features) && @dirty_features.size > 0)
+        load_feature_values()
+      end
+    
 			@features.uniq!
 			@compounds.uniq!
-      RestClient::Resource.new(@@config[:services]["opentox-dataset"], :user => @@users[:users].keys[0], :password => @@users[:users].values[0]).post(self.to_yaml, :content_type =>  "application/x-yaml").chomp.to_s		
-		end
-
-=begin
-		# create/add to entry from uris or Redland::Resources
-		def add(compound,feature,value)
-			compound = self.find_or_create_compound compound unless compound.class == Redland::Resource
-			feature = self.find_or_create_feature feature unless feature.class == Redland::Resource
-			data_entry = @model.subject OT['compound'], compound
-			if data_entry.nil?
-				data_entry = @model.create_resource
-				dataset = @model.subject(RDF['type'],OT[self.owl_class])
-				@model.add dataset, OT['dataEntry'], data_entry
-				@model.add data_entry, RDF['type'], OT["DataEntry"]
-				@model.add data_entry, OT['compound'], compound
-			end
-			values = @model.create_resource
-			@model.add data_entry, OT['values'], values
-			@model.add values, RDF['type'], OT['FeatureValue']
-			@model.add values, OT['feature'], feature
-			@model.add values, OT['value'], value.to_s
-		end
-
-		def add_tuple(compound,tuple)
-			compound = self.find_or_create_compound compound unless compound.class == Redland::Resource
-			data_entry = @model.subject OT['compound'], compound
-			if data_entry.nil?
-				data_entry = @model.create_resource
-				dataset = @model.subject(RDF['type'],OT[self.owl_class])
-				@model.add dataset, OT['dataEntry'], data_entry
-				@model.add data_entry, RDF['type'], OT["DataEntry"]
-				@model.add data_entry, OT['compound'], compound
-			end
-			@model.add data_entry, OT['values'], tuple
+      OpenTox::RestClientWrapper.post(@@config[:services]["opentox-dataset"],{:content_type =>  "application/x-yaml"},self.to_yaml).strip 	
 		end
 
-		def create_tuple(feature,t)
-			feature = self.find_or_create_feature feature unless feature.class == Redland::Resource
-			tuple = @model.create_resource
-			@model.add tuple, RDF['type'], OT["Tuple"]
-			@model.add tuple, OT['feature'], feature
-			t.each do |name,value|
-				f = self.find_or_create_feature name unless name.class == Redland::Resource
-				complex_value = @model.create_resource
-				feature = self.find_or_create_feature(name) 
-				@model.add tuple, OT['complexValue'], complex_value
-				@model.add complex_value, RDF['type'], OT["FeatureValue"]
-				@model.add complex_value, OT['feature'], f
-				@model.add complex_value, OT['value'], value.to_s
-      end
-  	
-			tuple
-		end
-
-		# find or create a new compound and return the resource
-		def find_or_create_compound(uri)
-			compound = @model.subject(DC["identifier"], uri)
-			if compound.nil?
-				compound = @model.create_resource(uri)
-				@model.add compound, RDF['type'], OT["Compound"]
-				@model.add compound, DC["identifier"], uri
-			end
-			compound
-		end
-
-		# find or create a new feature and return the resource
-		def find_or_create_feature(uri)
-			feature = @model.subject(DC["identifier"], uri)
-			if feature.nil?
-				feature = @model.create_resource(uri)
-				@model.add feature, RDF['type'], OT["Feature"]
-				@model.add feature, DC["identifier"], uri
-				@model.add feature, DC["title"], File.basename(uri).split(/#/)[1]
-				@model.add feature, DC['source'], uri
-			end
-			feature
-		end
-
-		def self.create(data, content_type = 'application/rdf+xml')
-      resource = RestClient::Resource.new(@@config[:services]["opentox-dataset"], :user => @@users[:users].keys[0], :password => @@users[:users].values[0])		  
-		  uri = resource.post data, :content_type => content_type
-			dataset = Dataset.new
-			dataset.read uri.chomp.to_s
-			dataset
-		end
-
-		def features
-			features = []
-			@model.subjects(RDF['type'], OT["Feature"]).each do |feature_node|
-				features << @model.object(feature_node,  DC["identifier"])#
-			end
-			features
-		end
-
-		def data
-			data = {}
-			@model.subjects(RDF['type'], OT['DataEntry']).each do |data_entry|
-				compound_node  = @model.object(data_entry, OT['compound'])
-				compound_uri = @model.object(compound_node, DC['identifier']).to_s
-				@model.find(data_entry, OT['values'], nil) do |s,p,values|
-					feature_node = @model.object values, OT['feature']
-					feature_uri = @model.object(feature_node, DC['identifier']).to_s.sub(/\^\^.*$/,'') # remove XML datatype
-					type = @model.object(values, RDF['type'])
-					if type == OT['FeatureValue']
-						value = @model.object(values, OT['value']).to_s
-						case value.to_s
-						when TRUE_REGEXP # defined in environment.rb
-							value = true
-						when FALSE_REGEXP # defined in environment.rb
-							value = false
-						else
-							LOGGER.warn compound_uri + " has value '" + value.to_s + "' for feature " + feature_uri
-							value = nil
-						end
-						data[compound_uri] = {} unless data[compound_uri]
-						data[compound_uri][feature_uri] = [] unless data[compound_uri][feature_uri]
-						data[compound_uri][feature_uri] << value unless value.nil?
-					elsif type == OT['Tuple']
-						entry = {}
-						data[compound_uri] = {} unless data[compound_uri]
-						data[compound_uri][feature_uri] = [] unless data[compound_uri][feature_uri]
-						@model.find(values, OT['complexValue'],nil) do |s,p,complex_value|
-							name_node = @model.object complex_value, OT['feature']
-							name = @model.object(name_node, DC['title']).to_s
-							value = @model.object(complex_value, OT['value']).to_s
-							v = value.sub(/\^\^.*$/,'') # remove XML datatype
-							v = v.to_f if v.match(/^[\.|\d]+$/) # guess numeric datatype
-							entry[name] = v
-						end
-						data[compound_uri][feature_uri] << entry
-					end
-				end
-			end
-			data
-		end
-
-		def compounds
-			compounds = []
-			@model.subjects(RDF['type'], OT["Compound"]).each do |compound_node|
-				compounds << @model.object(compound_node,  DC["identifier"]).to_s
-			end
-			compounds
-		end
-
-		# Delete a dataset
-		def delete
-  		resource = RestClient::Resource.new(@uri, :user => @@users[:users].keys[0], :password => @@users[:users].values[0])
-      resource.delete
+    def init_dirty_features(owl)
+      @dirty_features = @features
+      @owl = owl
     end
+  end
 
-		def to_owl
-		end
-
-		def from_owl
-		end
-
-=end
-	end
 
 end

data/lib/environment.rb

@@ -40,10 +40,77 @@ if @@config[:database]
 	end
 end
 
+# mail for error messages
+load File.join config_dir,"mail.rb" if File.exists?(File.join config_dir,"mail.rb")
+
+# hack: store sinatra in global var to make url_for and halt methods accessible
+before {$sinatra = self unless $sinatra}
+
+class Sinatra::Base
+  # overwriting halt to log halts (!= 202)
+  def halt(*response)
+    LOGGER.error "halt "+response.first.to_s+" "+(response.size>1 ? response[1].to_s : "") if response and response.first and response.first >= 300
+    # orig sinatra code:
+    response = response.first if response.length == 1
+    throw :halt, response
+  end
+end
+
 # logging
+class MyLogger < Logger
+  
+  def pwd
+    path = Dir.pwd.to_s
+    index = path.rindex(/\//)
+    return path if index==nil
+    path[(index+1)..-1]
+  end
+  
+  def trace()
+    lines = caller(0)
+    n = 2
+    line = lines[n]
+    
+    while (line =~ /spork.rb/ or line =~ /as_task/ or line =~ /environment.rb/)
+      n += 1
+      line = lines[n]
+    end
+  
+    index = line.rindex(/\/.*\.rb/)
+    return line if index==nil
+    line[index..-1]
+  end
+  
+  def format(msg)
+    pwd.ljust(18)+" :: "+msg.to_s+"           :: "+trace+" :: "+ENV['REMOTE_ADDR'].to_s
+  end
+  
+  def debug(msg)
+    super format(msg)
+  end
+  
+  def info(msg)
+    super format(msg)
+  end
+  
+  def warn(msg)
+    super format(msg)
+  end
+
+  def error(msg)
+    super format(msg)
+  end
+
+end
+
+
 logfile = "#{LOG_DIR}/#{ENV["RACK_ENV"]}.log"
-LOGGER = Logger.new(logfile,'daily') # daily rotation
-LOGGER.level = Logger::DEBUG
+LOGGER = MyLogger.new(logfile,'daily') # daily rotation
+
+#LOGGER = MyLogger.new(STDOUT)
+#LOGGER.datetime_format = "%Y-%m-%d %H:%M:%S "
+
+#LOGGER.level = Logger::DEBUG
 
 if File.exist?(user_file)
   @@users = YAML.load_file(user_file)
@@ -56,8 +123,7 @@ end
 begin
   0 < @@users[:users].keys.length
 rescue
-  puts "Please edit #{user_file} and restart your application. Create at least one user with password."
-  exit
+  raise "Please edit #{user_file} and restart your application. Create at least one user with password."
 end
 
 # RDF namespaces
@@ -65,7 +131,12 @@ RDF = Redland::Namespace.new 'http://www.w3.org/1999/02/22-rdf-syntax-ns#'
 OWL = Redland::Namespace.new 'http://www.w3.org/2002/07/owl#'
 DC = Redland::Namespace.new 'http://purl.org/dc/elements/1.1/'
 OT = Redland::Namespace.new 'http://www.opentox.org/api/1.1#'
+XML = Redland::Namespace.new 'http://www.w3.org/2001/XMLSchema#'
 
 # Regular expressions for parsing classification data
-TRUE_REGEXP = /^(true|active|1)/
-FALSE_REGEXP = /^(false|inactive|0)/
+TRUE_REGEXP = /^(true|active|$1^)/
+FALSE_REGEXP = /^(false|inactive|$0^)/
+
+# Task durations
+DEFAULT_TASK_MAX_DURATION = @@config[:default_task_max_duration]
+EXTERNAL_TASK_MAX_DURATION = @@config[:external_task_max_duration]

data/lib/features.rb

@@ -0,0 +1,15 @@
+module OpenTox
+  
+  module Feature
+    
+    def self.domain( feature_uri )
+      #TODO
+      if feature_uri =~ /ambit/
+        return nil
+      else
+        return ["true", "false"]
+      end
+    end
+
+  end
+end