opentox-ruby 0.0.2 → 1.0.0

data/lib/helper.rb

@@ -1,26 +1,99 @@
 helpers do
 
-	# Authentification
-  def protected!
-    response['WWW-Authenticate'] = %(Basic realm="Testing HTTP Auth") and \
-    throw(:halt, [401, "Not authorized\n"]) and \
-    return unless authorized?
+  # Authentification
+  def protected!(subjectid)
+    if env["session"]
+      unless authorized?(subjectid)
+        flash[:notice] = "You don't have access to this section: "
+        redirect back
+      end
+    elsif !env["session"] && subjectid
+      unless authorized?(subjectid)
+        LOGGER.debug "URI not authorized: clean: " + clean_uri("#{request.env['rack.url_scheme']}://#{request.env['HTTP_HOST']}#{request.env['REQUEST_URI']}").to_s + " full: #{request.env['rack.url_scheme']}://#{request.env['HTTP_HOST']}#{request.env['REQUEST_URI']} with request: #{request.env['REQUEST_METHOD']}"
+        raise OpenTox::NotAuthorizedError.new "Not authorized" 
+      end
+    else
+      raise OpenTox::NotAuthorizedError.new "Not authorized" unless authorized?(subjectid)
+    end
   end
 
-  def authorized?
-    @auth ||=  Rack::Auth::Basic::Request.new(request.env)
-    @auth.provided? && @auth.basic? && @auth.credentials && @auth.credentials == ['api', API_KEY]
+  #Check Authorization for URI with method and subjectid. 
+  def authorized?(subjectid)
+    request_method = request.env['REQUEST_METHOD']
+    uri = clean_uri("#{request.env['rack.url_scheme']}://#{request.env['HTTP_HOST']}#{request.env['REQUEST_URI']}")
+    request_method = "GET" if request_method == "POST" &&  uri =~ /\/model\/\d+\/?$/
+    return OpenTox::Authorization.authorized?(uri, request_method, subjectid)
   end
 
-	    
-=begin
-	def xml(object)
-		builder do |xml| 
-			xml.instruct!
-			object.to_xml
-		end
-	end
-=end
+  #cleans URI from querystring and file-extension. Sets port 80 to emptystring
+  # @param [String] uri 
+  def clean_uri(uri)
+    uri = uri.sub(" ", "%20")          #dirty hacks => to fix
+    uri = uri[0,uri.index("InChI=")] if uri.index("InChI=") 
+    
+    out = URI.parse(uri)
+    out.path = out.path[0, out.path.length - (out.path.reverse.rindex(/\/{1}\d+\/{1}/))] if out.path.index(/\/{1}\d+\/{1}/)  #cuts after /id/ for a&a
+    port = (out.scheme=="http" && out.port==80)||(out.scheme=="https" && out.port==443) ? "" : ":#{out.port.to_s}" 
+    "#{out.scheme}://#{out.host}#{port}#{out.path.chomp("/")}" #"
+  end
+
+  #unprotected uri for login
+  def login_requests
+    return env['REQUEST_URI'] =~ /\/login$/ 
+   end
+
+  def uri_available?(urlStr)
+    url = URI.parse(urlStr)
+    unless @subjectid
+      Net::HTTP.start(url.host, url.port) do |http|
+        return http.head(url.request_uri).code == "200"
+      end
+    else
+      Net::HTTP.start(url.host, url.port) do |http|
+        return http.post(url.request_uri, "subjectid=#{@subjectid}").code == "202"
+      end
+    end
+  end
 
 end
 
+before do
+  unless !AA_SERVER or login_requests or CONFIG[:authorization][:free_request].include?(env['REQUEST_METHOD']) 
+    begin
+      subjectid = nil
+      subjectid = session[:subjectid] if session[:subjectid]
+      subjectid = params[:subjectid]  if params[:subjectid] and !subjectid
+      subjectid = request.env['HTTP_SUBJECTID'] if request.env['HTTP_SUBJECTID'] and !subjectid
+      subjectid = request.cookies["subjectid"] unless subjectid
+      # see http://rack.rubyforge.org/doc/SPEC.html
+      subjectid = CGI.unescape(subjectid) if subjectid.include?("%23")
+      @subjectid = subjectid
+    rescue
+      #LOGGER.debug "OpenTox ruby api wrapper: helper before filter: NO subjectid for URI: #{request.env['rack.url_scheme']}://#{request.env['HTTP_HOST']}#{request.env['REQUEST_URI']}"
+      subjectid = ""
+    end
+    @subjectid = subjectid
+    protected!(subjectid)
+
+    extension = File.extname(request.path_info) # params[:id] is not yet available
+    unless extension.empty?
+     #request.path_info.sub!(/\.#{extension}$/,'')
+     case extension
+     when "html"
+       @accept = 'text/html'
+     when "yaml"
+       @accept = 'application/x-yaml'
+     when "csv"
+       @accept = 'text/csv'
+     when "rdfxml"
+       @accept = 'application/rdf+xml'
+     when "xls"
+       @accept = 'application/ms-excel'
+     else
+       halt 404, "File format #{extension} not supported."
+     end
+   end
+  
+  end
+end
+

data/lib/model.rb

@@ -6,33 +6,71 @@ module OpenTox
 
     # 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)
-      if CONFIG[:yaml_hosts].include?(URI.parse(@uri).host)
-        accept = 'application/x-yaml' 
-      else
-        accept = 'application/rdf+xml'
-      end
-      begin
-        RestClientWrapper.post(@uri,{:accept => accept},params).to_s
-      rescue => e
-        LOGGER.error "Failed to run #{@uri} with #{params.inspect} (#{e.inspect})"
-        raise "Failed to run #{@uri} with #{params.inspect}"
+    def run( params, accept_header=nil, waiting_task=nil )
+      unless accept_header
+        if CONFIG[:yaml_hosts].include?(URI.parse(@uri).host)
+          accept_header = 'application/x-yaml' 
+        else
+          accept_header = 'application/rdf+xml'
+        end
       end
+      LOGGER.info "running model "+@uri.to_s+", params: "+params.inspect+", accept: "+accept_header.to_s
+      RestClientWrapper.post(@uri,params,{:accept => accept_header},waiting_task).to_s
     end
 
     # Generic OpenTox model class for all API compliant services
     class Generic
       include Model
+      
+      # Find Generic Opentox Model via URI, and loads metadata, could raise NotFound/NotAuthorized error 
+      # @param [String] uri Model URI
+      # @return [OpenTox::Model::Generic] Model instance
+      def self.find(uri,subjectid=nil)
+        return nil unless uri
+        model = Generic.new(uri)
+        model.load_metadata(subjectid)
+        raise "could not load model metadata '"+uri.to_s+"'" if model.metadata==nil or model.metadata.size==0
+        model
+      end
+    
+       # provides feature type, possible types are "regression" or "classification"
+       # @return [String] feature type, "unknown" if type could not be estimated
+      def feature_type(subjectid=nil)
+        return @feature_type if @feature_type
+        
+        # dynamically perform restcalls if necessary
+        load_metadata(subjectid) if @metadata==nil or @metadata.size==0 or (@metadata.size==1 && @metadata.values[0]==@uri)
+        algorithm = OpenTox::Algorithm::Generic.find(@metadata[OT.algorithm], subjectid)
+        algorithm_title = algorithm ? algorithm.metadata[DC.title] : nil
+        algorithm_type = algorithm ? algorithm.metadata[OT.isA] : nil
+        dependent_variable = OpenTox::Feature.find( @metadata[OT.dependentVariables],subjectid )
+        dependent_variable_type = dependent_variable ? dependent_variable.feature_type : nil
+        type_indicators = [dependent_variable_type, @metadata[OT.isA], @metadata[DC.title], 
+          @uri, algorithm_type, algorithm_title] 
+        type_indicators.each do |type|
+          case type
+          when /(?i)classification/
+            @feature_type =  "classification"
+            break
+          when /(?i)regression/
+            @feature_type = "regression"
+          end
+        end
+        raise "unknown model "+type_indicators.inspect unless @feature_type
+        @feature_type
+      end
+      
     end
-   
+    
     # Lazy Structure Activity Relationship class
     class Lazar
 
       include Model
       include Algorithm
 
-      attr_accessor :compound, :prediction_dataset, :features, :effects, :activities, :p_values, :fingerprints, :feature_calculation_algorithm, :similarity_algorithm, :prediction_algorithm, :min_sim
+      attr_accessor :compound, :prediction_dataset, :features, :effects, :activities, :p_values, :fingerprints, :feature_calculation_algorithm, :similarity_algorithm, :prediction_algorithm, :min_sim, :subjectid
 
       def initialize(uri=nil)
 
@@ -60,15 +98,15 @@ module OpenTox
 
       # Get URIs of all lazar models
       # @return [Array] List of lazar model URIs
-      def self.all
-        RestClientWrapper.get(CONFIG[:services]["opentox-model"]).to_s.split("\n")
+      def self.all(subjectid=nil)
+        RestClientWrapper.get(CONFIG[:services]["opentox-model"], :subjectid => subjectid).to_s.split("\n")
       end
 
       # Find a lazar model
       # @param [String] uri Model URI
       # @return [OpenTox::Model::Lazar] lazar model
-      def self.find(uri)
-        YAML.load RestClientWrapper.get(uri,:accept => 'application/x-yaml')
+      def self.find(uri, subjectid=nil)
+        YAML.load RestClientWrapper.get(uri,{:accept => 'application/x-yaml', :subjectid => subjectid})
       end
 
       # Create a new lazar model
@@ -77,7 +115,7 @@ module OpenTox
       def self.create(params)
         lazar_algorithm = OpenTox::Algorithm::Generic.new File.join( CONFIG[:services]["opentox-algorithm"],"lazar")
         model_uri = lazar_algorithm.run(params)
-        OpenTox::Model::Lazar.find(model_uri)
+        OpenTox::Model::Lazar.find(model_uri, params[:subjectid])
       end
 
       # Get a parameter value
@@ -89,21 +127,30 @@ module OpenTox
 
       # Predict a dataset
       # @param [String] dataset_uri Dataset URI
+      # @param [optional,subjectid] 
+      # @param [optional,OpenTox::Task] waiting_task (can be a OpenTox::Subtask as well), progress is updated accordingly
       # @return [OpenTox::Dataset] Dataset with predictions
-      def predict_dataset(dataset_uri)
-        @prediction_dataset = Dataset.create
+      def predict_dataset(dataset_uri, subjectid=nil, waiting_task=nil)
+        @prediction_dataset = Dataset.create(CONFIG[:services]["opentox-dataset"], subjectid)
         @prediction_dataset.add_metadata({
           OT.hasSource => @uri,
           DC.creator => @uri,
           DC.title => URI.decode(File.basename( @metadata[OT.dependentVariables] )),
           OT.parameters => [{DC.title => "dataset_uri", OT.paramValue => dataset_uri}]
         })
-        d = Dataset.new(dataset_uri)
-        d.load_compounds
+        d = Dataset.new(dataset_uri,subjectid)
+        d.load_compounds(subjectid)
+        count = 0
         d.compounds.each do |compound_uri|
-          predict(compound_uri,false)
+          begin
+            predict(compound_uri,false,subjectid)
+            count += 1
+            waiting_task.progress( count/d.compounds.size.to_f*100.0 ) if waiting_task
+          rescue => ex
+            LOGGER.warn "prediction for compound "+compound_uri.to_s+" failed: "+ex.message
+          end
         end
-        @prediction_dataset.save
+        @prediction_dataset.save(subjectid)
         @prediction_dataset
       end
 
@@ -111,7 +158,7 @@ module OpenTox
       # @param [String] compound_uri Compound URI
       # @param [optinal,Boolean] verbose Verbose prediction (output includes neighbors and features)
       # @return [OpenTox::Dataset] Dataset with prediction
-      def predict(compound_uri,verbose=false)
+      def predict(compound_uri,verbose=false,subjectid=nil)
 
         @compound = Compound.new compound_uri
         features = {}
@@ -119,7 +166,7 @@ module OpenTox
         unless @prediction_dataset
           #@prediction_dataset = cached_prediction
           #return @prediction_dataset if cached_prediction
-          @prediction_dataset = Dataset.create
+          @prediction_dataset = Dataset.create(CONFIG[:services]["opentox-dataset"], subjectid)
           @prediction_dataset.add_metadata( {
             OT.hasSource => @uri,
             DC.creator => @uri,
@@ -129,7 +176,7 @@ module OpenTox
           } )
         end
 
-        return @prediction_dataset if database_activity
+        return @prediction_dataset if database_activity(subjectid)
 
         neighbors
         prediction = eval("#{@prediction_algorithm}(@neighbors,{:similarity_algorithm => @similarity_algorithm, :p_values => @p_values})")
@@ -217,7 +264,7 @@ module OpenTox
           end
         end
 
-        @prediction_dataset.save
+        @prediction_dataset.save(subjectid)
         @prediction_dataset
       end
 
@@ -245,11 +292,11 @@ module OpenTox
 
       # Find database activities and store them in @prediction_dataset
       # @return [Boolean] true if compound has databasse activities, false if not
-      def database_activity
+      def database_activity(subjectid)
         if @activities[@compound.uri]
           @activities[@compound.uri].each { |act| @prediction_dataset.add @compound.uri, @metadata[OT.dependentVariables], act }
           @prediction_dataset.add_metadata(OT.hasSource => @metadata[OT.trainingDataset])
-          @prediction_dataset.save
+          @prediction_dataset.save(subjectid)
           true
         else
           false
@@ -257,13 +304,13 @@ module OpenTox
       end
 
       # Save model at model service
-      def save
-        self.uri = RestClientWrapper.post(@uri,{:content_type =>  "application/x-yaml"},self.to_yaml)
+      def save(subjectid)
+        self.uri = RestClientWrapper.post(@uri,self.to_yaml,{:content_type =>  "application/x-yaml", :subjectid => subjectid})
       end
 
       # Delete model at model service
-      def delete
-        RestClientWrapper.delete @uri unless @uri == CONFIG[:services]["opentox-model"]
+      def delete(subjectid)
+        RestClientWrapper.delete(@uri, :subjectid => subjectid) unless @uri == CONFIG[:services]["opentox-model"]
       end
 
     end

data/lib/ontology_service.rb

@@ -0,0 +1,43 @@
+module OpenTox
+  module OntologyService
+    module Endpoints
+      require 'sparql/client'
+      @sparql = SPARQL::Client.new("http://apps.ideaconsult.net:8080/ontology")
+      def self.qs(classname="Endpoints")
+        return "PREFIX ot:<http://www.opentox.org/api/1.1#>
+        PREFIX ota:<http://www.opentox.org/algorithms.owl#>
+        PREFIX owl:<http://www.w3.org/2002/07/owl#>
+        PREFIX dc:<http://purl.org/dc/elements/1.1/>
+        PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+        PREFIX rdf:<http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+        PREFIX otee:<http://www.opentox.org/echaEndpoints.owl#>
+        PREFIX toxcast:<http://www.opentox.org/toxcast.owl#>
+          select ?Endpoints ?title ?id
+          where {?Endpoints rdfs:subClassOf otee:#{classname}.
+          OPTIONAL {?Endpoints dc:title ?title}.
+          OPTIONAL {?Endpoints dc:identifier ?id}.}
+          ORDER BY ?title"
+      end
+      
+      def self.make_option_list(endpoint="Endpoints", level=1)
+        out = ""
+        results = @sparql.query(qs(endpoint)) rescue results = []
+        results.each do |result|
+          endpointname = result.Endpoints.to_s.split('#').last
+          title = result.bound?(:title) ? result.title : endpointname     
+          out += "<option value='#{title}' id='#{endpointname}' class='level_#{level}'>#{title}</option>\n"
+          out += make_option_list(endpointname, level + 1)
+        end
+        return out
+      end
+    
+      def self.get_endpoint_selectlist(include_blank=true)
+        out = "<select id='endpoint' name='endpoint'>\n"
+        out += "<option value='' id='please_select'>Please select</option>\n" if include_blank 
+        out += make_option_list
+        out += "</select>\n"
+        return out
+      end
+    end
+  end
+end

data/lib/opentox-ruby.rb

@@ -1,4 +1,4 @@
-['rubygems', 'sinatra', 'sinatra/url_for', 'rest_client', 'yaml', 'cgi', 'spork', 'overwrite', 'environment'].each do |lib|
+['rubygems', 'sinatra', 'sinatra/url_for', 'ohm', 'rest_client', 'yaml', 'cgi', 'spork', 'error', 'overwrite', 'environment'].each do |lib|
 	require lib
 end
 
@@ -8,6 +8,7 @@ rescue LoadError
 	puts "Please install Openbabel with 'rake openbabel:install' in the compound component"
 end
 
-['opentox', 'compound','dataset', 'parser','serializer', 'algorithm','model','task','validation','feature', 'rest_client_wrapper'].each do |lib|
+['opentox', 'compound','dataset', 'parser','serializer', 'algorithm','model','task','validation','feature', 
+ 'rest_client_wrapper', 'authorization', 'policy', 'helper', 'to-html' ].each do |lib|
 	require lib
 end

data/lib/opentox.rb

@@ -19,14 +19,14 @@ module OpenTox
 
   # Get all objects from a service
   # @return [Array] List of available URIs
-  def self.all(uri)
-    RestClientWrapper.get(uri,:accept => "text/uri-list").to_s.split(/\n/)
+  def self.all(uri, subjectid=nil)
+    RestClientWrapper.get(uri,:accept => "text/uri-list", :subjectid => subjectid).to_s.split(/\n/)
   end
 
   # Load (and return) metadata from object URI
   # @return [Hash] Metadata
-  def load_metadata
-    @metadata = Parser::Owl::Generic.new(@uri).load_metadata
+  def load_metadata(subjectid=nil)
+    @metadata = Parser::Owl::Generic.new(@uri).load_metadata(subjectid)
     @metadata
   end
 
@@ -43,5 +43,10 @@ module OpenTox
     s.to_rdfxml
   end
 
+  # deletes the resource, deletion should have worked when no RestCallError raised
+  def delete(subjectid=nil)
+    RestClientWrapper.delete(uri,:subjectid => subjectid)
+  end
+
 end
 

data/lib/overwrite.rb

@@ -1,38 +1,91 @@
 # class overwrites aka monkey patches
-# hack: store sinatra in global var to make url_for and halt methods accessible
-before{ $sinatra = self unless $sinatra }
+# hack: store sinatra instance in global var $url_provider to make url_for and halt methods accessible
+before {
+  raise "should not happen, url provider already differently initialized "+
+    $url_provider.request.host.to_s+" != "+self.request.host.to_s if
+    $url_provider and $url_provider.request.host!=self.request.host and 
+    $url_provider.request.script_name!=self.request.script_name
+  $url_provider = self
+  # stupid internet explorer does not ask for text/html, add this manually 
+  request.env['HTTP_ACCEPT'] += ";text/html" if request.env["HTTP_USER_AGENT"]=~/MSIE/
+}
+
+# Error handling
+# Errors are logged as error and formated according to acccept-header
+# Non OpenTox::Errors (defined in error.rb) are handled as internal error (500), stacktrace is logged
+# IMPT: set sinatra settings :show_exceptions + :raise_errors to false in config.ru, otherwise Rack::Showexceptions takes over
+error Exception do
+  error = request.env['sinatra.error']
+  # log error message and backtrace to logfile
+  LOGGER.error error.class.to_s+": "+error.message
+  LOGGER.error ":\n"+error.backtrace.join("\n")
+  
+  actor = "#{request.env['rack.url_scheme']}://#{request.env['HTTP_HOST']}#{request.env['REQUEST_URI']}"
+  rep = OpenTox::ErrorReport.create(error, actor)
+
+  case request.env['HTTP_ACCEPT']
+  when /rdf/
+    content_type 'application/rdf+xml'
+    halt error.http_code,rep.to_rdfxml
+  when /html/
+    content_type 'text/html'
+    halt error.http_code,(OpenTox.text_to_html rep.to_yaml, @subjectid)
+  else
+    content_type 'application/x-yaml'
+    halt error.http_code,rep.to_yaml
+  end
+end
 
 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
+
+  def return_task( task )
+    code = task.running? ? 202 : 200
+    case request.env['HTTP_ACCEPT']
+    when /rdf/
+      response['Content-Type'] = "application/rdf+xml"
+      halt code,task.to_rdfxml
+    when /yaml/
+      response['Content-Type'] = "application/x-yaml"
+      halt code,task.to_yaml # PENDING differs from task-webservice
+    when /html/
+      response['Content-Type'] = "text/html"
+      halt code,OpenTox.text_to_html(task.to_yaml, @subjectid)
+    else # default /uri-list/
+      response['Content-Type'] = "text/uri-list"
+      halt code,task.uri+"\n"
+    end
   end
 end
 
 class String
-    def task_uri?
-      self.uri? && !self.match(/task/).nil?
-    end
-    
-    def dataset_uri?
-     self.uri? && !self.match(/dataset/).nil?
-    end
-   
-    def self.model_uri?
-     self.uri? && !self.match(/model/).nil?
-    end
+  def task_uri?
+    self.uri? && !self.match(/task/).nil?
+  end
+  
+  def dataset_uri?
+   self.uri? && !self.match(/dataset/).nil?
+  end
+ 
+  def self.model_uri?
+   self.uri? && !self.match(/model/).nil?
+  end
 
-    def uri?
-      begin
-        u = URI::parse(self)
-        return (u.scheme!=nil and u.host!=nil)
-      rescue URI::InvalidURIError
-        return false
-      end
+  def uri?
+    begin
+      u = URI::parse(self)
+      return (u.scheme!=nil and u.host!=nil)
+    rescue URI::InvalidURIError
+      return false
     end
+  end
+
+  def underscore
+    self.gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+  end
 end
 
 require 'logger'
@@ -52,7 +105,7 @@ class OTLogger < Logger
     n = 2
     line = lines[n]
     
-    while (line =~ /spork.rb/ or line =~ /create/ or line =~ /ot-logger.rb/)
+    while (line =~ /spork.rb/ or line =~ /create/ or line =~ /overwrite.rb/)
       n += 1
       line = lines[n]
     end
@@ -63,7 +116,7 @@ class OTLogger < Logger
   end
   
   def format(msg)
-    pwd.ljust(18)+" :: "+msg.to_s+"           :: "+trace+" :: "+($sinatra ? $sinatra.request.env['REMOTE_ADDR'] : nil).to_s
+    pwd.ljust(18)+" :: "+msg.to_s+"           :: "+trace
   end
   
   def debug(msg)
@@ -84,3 +137,9 @@ class OTLogger < Logger
 
 end
 
+# make migration from datamapper more straightforward
+class Ohm::Model
+  def self.get(id)
+    self[id]
+  end
+end