opentox-ruby 0.0.2 → 1.0.0

data/lib/compound.rb

@@ -68,6 +68,12 @@ module OpenTox
       c
     end
 
+		# Get InChI
+    # @return [String] InChI string
+		def to_inchi
+      @inchi
+		end
+
 		# Get (canonical) smiles
     # @return [String] Smiles string
 		def to_smiles

data/lib/config/config_ru.rb

@@ -12,6 +12,7 @@ $stdout.sync = true
 $stderr.sync = true
 set :logging, false
 set :raise_errors, true 
+set :lock, true
 
 ['public','tmp'].each do |dir|
 	FileUtils.mkdir_p dir unless File.exists?(dir)

data/lib/dataset.rb

@@ -14,7 +14,7 @@ module OpenTox
     #   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)
+    def initialize(uri=nil,subjectid=nil)
       super uri
       @features = {}
       @compounds = []
@@ -26,9 +26,9 @@ module OpenTox
     #   dataset = OpenTox::Dataset.create
     # @param [optional, String] uri Dataset URI
     # @return [OpenTox::Dataset] Dataset object
-    def self.create(uri=CONFIG[:services]["opentox-dataset"])
-      dataset = Dataset.new
-      dataset.save
+    def self.create(uri=CONFIG[:services]["opentox-dataset"], subjectid=nil)
+      dataset = Dataset.new(nil,subjectid)
+      dataset.save(subjectid)
       dataset
     end
 
@@ -38,29 +38,43 @@ module OpenTox
     # - you will have to set remaining metadata manually
     # @param [String] file CSV file path
     # @return [OpenTox::Dataset] Dataset object with CSV data
-    def self.create_from_csv_file(file) 
-      dataset = Dataset.create
+    def self.create_from_csv_file(file, subjectid=nil) 
+      dataset = Dataset.create(CONFIG[:services]["opentox-dataset"], subjectid)
       parser = Parser::Spreadsheets.new
       parser.dataset = dataset
       parser.load_csv(File.open(file).read)
-      dataset.save
+      dataset.save(subjectid)
       dataset
     end
-
+    
     # Find a dataset and load all data. This can be time consuming, use Dataset.new together with one of the load_* methods for a fine grained control over data loading.
     # @param [String] uri Dataset URI
     # @return [OpenTox::Dataset] Dataset object with all data
-    def self.find(uri)
-      dataset = Dataset.new(uri)
-      dataset.load_all
+    def self.find(uri, subjectid=nil)
+      return nil unless uri
+      dataset = Dataset.new(uri, subjectid)
+      dataset.load_all(subjectid)
       dataset
     end
+    
+    # replaces find as exist check, takes not as long, does NOT raise an un-authorized exception
+    # @param [String] uri Dataset URI
+    # @return [Boolean] true if dataset exists and user has get rights, false else 
+    def self.exist?(uri, subjectid=nil)
+      return false unless uri
+      dataset = Dataset.new(uri, subjectid)
+      begin
+        dataset.load_metadata( subjectid ).size > 0
+      rescue
+        false
+      end
+    end
 
     # Get all datasets from a service
     # @param [optional,String] uri URI of the dataset service, defaults to service specified in configuration
     # @return [Array] Array of dataset object without data (use one of the load_* methods to pull data from the server)
-    def self.all(uri=CONFIG[:services]["opentox-dataset"])
-      RestClientWrapper.get(uri,:accept => "text/uri-list").to_s.each_line.collect{|u| Dataset.new(u)}
+    def self.all(uri=CONFIG[:services]["opentox-dataset"], subjectid=nil)
+      RestClientWrapper.get(uri,{:accept => "text/uri-list",:subjectid => subjectid}).to_s.each_line.collect{|u| Dataset.new(u, subjectid)}
     end
 
     # Load YAML representation into the dataset
@@ -71,16 +85,21 @@ module OpenTox
     end
 
     def load_rdfxml(rdfxml)
-      load_rdfxml_file Tempfile.open("ot-rdfxml"){|f| f.write(rdfxml)}.path
+      raise "rdfxml data is empty" if rdfxml.to_s.size==0
+      file = Tempfile.new("ot-rdfxml")
+      file.puts rdfxml
+      file.close
+      load_rdfxml_file file
+      file.delete
     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 load_rdfxml_file(file)
-      parser = Parser::Owl::Dataset.new @uri
+    def load_rdfxml_file(file, subjectid=nil)
+      parser = Parser::Owl::Dataset.new @uri, subjectid
       parser.uri = file.path
-      copy parser.load_uri
+      copy parser.load_uri(subjectid)
     end
 
     # Load CSV string (format specification: http://toxcreate.org/help)
@@ -89,8 +108,8 @@ module OpenTox
     # - 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 load_csv(csv) 
-      save unless @uri # get a uri for creating features
+    def load_csv(csv, subjectid=nil) 
+      save(subjectid) unless @uri # get a uri for creating features
       parser = Parser::Spreadsheets.new
       parser.dataset = self
       parser.load_csv(csv)
@@ -102,8 +121,8 @@ module OpenTox
     # - 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 load_spreadsheet(book)
-      save unless @uri # get a uri for creating features
+    def load_spreadsheet(book, subjectid=nil)
+      save(subjectid) unless @uri # get a uri for creating features
       parser = Parser::Spreadsheets.new
       parser.dataset = self
       parser.load_spreadsheet(book)
@@ -111,26 +130,26 @@ module OpenTox
     
     # Load and return only metadata of a Dataset object
     # @return [Hash] Metadata of the dataset
-    def load_metadata
-      add_metadata Parser::Owl::Dataset.new(@uri).load_metadata
+    def load_metadata(subjectid=nil)
+      add_metadata Parser::Owl::Dataset.new(@uri, subjectid).load_metadata(subjectid)
       self.uri = @uri if @uri # keep uri
       @metadata
     end
 
     # Load all data (metadata, data_entries, compounds and features) from URI
-    def load_all
+    def load_all(subjectid=nil)
       if (CONFIG[:yaml_hosts].include?(URI.parse(@uri).host))
-        copy YAML.load(RestClientWrapper.get(@uri, :accept => "application/x-yaml"))
+        copy YAML.load(RestClientWrapper.get(@uri, {:accept => "application/x-yaml", :subjectid => subjectid}))
       else
-        parser = Parser::Owl::Dataset.new(@uri)
-        copy parser.load_uri
+        parser = Parser::Owl::Dataset.new(@uri, subjectid)
+        copy parser.load_uri(subjectid)
       end
     end
 
     # Load and return only compound URIs from the dataset service
     # @return [Array]  Compound URIs in the dataset
-    def load_compounds
-      RestClientWrapper.get(File.join(uri,"compounds"),:accept=> "text/uri-list").to_s.each_line do |compound_uri|
+    def load_compounds(subjectid=nil)
+      RestClientWrapper.get(File.join(uri,"compounds"),{:accept=> "text/uri-list", :subjectid => subjectid}).to_s.each_line do |compound_uri|
         @compounds << compound_uri.chomp
       end
       @compounds.uniq!
@@ -138,9 +157,9 @@ module OpenTox
 
     # Load and return only features from the dataset service
     # @return [Hash]  Features of the dataset
-    def load_features
-      parser = Parser::Owl::Dataset.new(@uri)
-      @features = parser.load_features
+    def load_features(subjectid=nil)
+      parser = Parser::Owl::Dataset.new(@uri, subjectid)
+      @features = parser.load_features(subjectid)
       @features
     end
 
@@ -218,7 +237,7 @@ module OpenTox
       @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
+      @data_entries[compound][feature] << value if value!=nil
     end
 
     # Add/modify metadata, existing entries will be overwritten
@@ -242,34 +261,70 @@ module OpenTox
     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, subjectid=nil)
+      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|
+            unless @data_entries[c][f]
+              dataset.add(c,f,nil)
+            else
+              @data_entries[c][f].each do |v|
+                dataset.add(c,f,v)
+              end
+            end
+          end
+        end
+      end
+      dataset.add_metadata(metadata)
+      dataset.save(subjectid)
+      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
+    def save(subjectid=nil)
       # TODO: rewrite feature URI's ??
       @compounds.uniq!
       if @uri
         if (CONFIG[:yaml_hosts].include?(URI.parse(@uri).host))
-          RestClientWrapper.post(@uri,{:content_type =>  "application/x-yaml"},self.to_yaml)
+          RestClientWrapper.post(@uri,self.to_yaml,{:content_type =>  "application/x-yaml", :subjectid => subjectid})
         else
           File.open("ot-post-file.rdf","w+") { |f| f.write(self.to_rdfxml); @path = f.path }
-          task_uri = RestClient.post(@uri, {:file => File.new(@path)},{:accept => "text/uri-list"}).to_s.chomp
+          task_uri = RestClient.post(@uri, {:file => File.new(@path)},{:accept => "text/uri-list" , :subjectid => subjectid}).to_s.chomp
           #task_uri = `curl -X POST -H "Accept:text/uri-list" -F "file=@#{@path};type=application/rdf+xml" http://apps.ideaconsult.net:8080/ambit2/dataset`
           Task.find(task_uri).wait_for_completion
-          self.uri = RestClientWrapper.get(task_uri,:accept => 'text/uri-list')
+          self.uri = RestClientWrapper.get(task_uri,{:accept => 'text/uri-list', :subjectid => subjectid})
         end
       else
         # create dataset if uri is empty
-        self.uri = RestClientWrapper.post(CONFIG[:services]["opentox-dataset"],{}).to_s.chomp
+        self.uri = RestClientWrapper.post(CONFIG[:services]["opentox-dataset"],{:subjectid => subjectid}).to_s.chomp
       end
       @uri
     end
 
     # Delete dataset at the dataset service
-    def delete
-      RestClientWrapper.delete @uri
+    def delete(subjectid=nil)
+      RestClientWrapper.delete(@uri, :subjectid => subjectid)
     end
 
     private
@@ -293,9 +348,9 @@ module OpenTox
     # Find a prediction dataset and load all data. 
     # @param [String] uri Prediction dataset URI
     # @return [OpenTox::Dataset] Prediction dataset object with all data
-    def self.find(uri)
-      prediction = LazarPrediction.new(uri)
-      prediction.load_all
+    def self.find(uri, subjectid=nil)
+      prediction = LazarPrediction.new(uri, subjectid)
+      prediction.load_all(subjectid)
       prediction
     end
 

data/lib/environment.rb

@@ -23,22 +23,8 @@ else
 end
 
 # database
-if CONFIG[:database]
-	['dm-core', 'dm-serializer', 'dm-timestamps', 'dm-types', 'dm-migrations', 'dm-validations' ].each{|lib| require lib }
-	case CONFIG[:database][:adapter]
-	when /sqlite/i
-		db_dir = File.join(basedir, "db")
-		FileUtils.mkdir_p db_dir
-		DataMapper::setup(:default, "sqlite3://#{db_dir}/opentox.sqlite3")
-	else
-		DataMapper.setup(:default, { 
-				:adapter  => CONFIG[:database][:adapter],
-				:database => CONFIG[:database][:database],
-				:username => CONFIG[:database][:username],
-				:password => CONFIG[:database][:password],
-				:host     => CONFIG[:database][:host]})
-	end
-end
+`redis-server /opt/redis/redis.conf` unless File.exists? "/var/run/redis.pid"
+Ohm.connect :thread_safe => true
 
 # load mail settings for error messages
 load File.join config_dir,"mail.rb" if File.exists?(File.join config_dir,"mail.rb")
@@ -54,8 +40,8 @@ else
 end
 
 # Regular expressions for parsing classification data
-TRUE_REGEXP = /^(true|active|1|1.0)$/i
-FALSE_REGEXP = /^(false|inactive|0|0.0)$/i
+TRUE_REGEXP = /^(true|active|1|1.0|tox)$/i
+FALSE_REGEXP = /^(false|inactive|0|0.0|low tox)$/i
 
 # Task durations
 DEFAULT_TASK_MAX_DURATION = 36000
@@ -83,6 +69,11 @@ class OwlNamespace
 
 end
 
+AA_SERVER = CONFIG[:authorization] ? (CONFIG[:authorization][:server] ? CONFIG[:authorization][:server] : nil) : nil
+CONFIG[:authorization][:authenticate_request] = [""] unless CONFIG[:authorization][:authenticate_request]
+CONFIG[:authorization][:authorize_request] =  [""] unless CONFIG[:authorization][:authorize_request]
+CONFIG[:authorization][:free_request] =  [""] unless CONFIG[:authorization][:free_request]
+
 RDF = OwlNamespace.new 'http://www.w3.org/1999/02/22-rdf-syntax-ns#'
 OWL = OwlNamespace.new 'http://www.w3.org/2002/07/owl#'
 DC =  OwlNamespace.new 'http://purl.org/dc/elements/1.1/'

data/lib/error.rb

@@ -0,0 +1,99 @@
+
+# adding additional fields to Exception class to format errors according to OT-API
+class Exception
+  attr_accessor :errorCause
+  def http_code; 500; end
+end
+
+module OpenTox
+  
+  class BadRequestError < RuntimeError
+    def http_code; 400; end
+  end
+  
+  class NotAuthorizedError < RuntimeError
+    def http_code; 401; end
+  end
+  
+  class NotFoundError < RuntimeError
+    def http_code; 404; end
+  end
+
+  class ServiceUnavailableError < RuntimeError
+    def http_code; 503; end
+  end
+  
+  class RestCallError < RuntimeError
+    attr_accessor :rest_params
+    def http_code; 502; end
+  end
+
+  class ErrorReport
+    
+    # TODO replace params with URIs (errorCause -> OT.errorCause)
+    attr_reader :message, :actor, :errorCause, :http_code, :errorDetails, :errorType
+
+    private
+    def initialize( http_code, erroType, message, actor, errorCause, rest_params=nil, backtrace=nil )
+      @http_code = http_code
+      @errorType = erroType
+      @message = message
+      @actor = actor
+      @errorCause = errorCause
+      @rest_params = rest_params
+      @backtrace = backtrace
+    end
+    
+    public
+    # creates a error report object, from an ruby-exception object
+    # @param [Exception] error
+    # @param [String] actor, URI of the call that cause the error
+    def self.create( error, actor )
+      rest_params = error.rest_params if error.is_a?(OpenTox::RestCallError) and error.rest_params
+      backtrace = error.backtrace.short_backtrace if CONFIG[:backtrace]
+      ErrorReport.new( error.http_code, error.class.to_s, error.message, actor, error.errorCause, rest_params, backtrace )
+    end
+    
+    def self.from_rdf(rdf)
+      metadata = OpenTox::Parser::Owl.from_rdf( rdf, OT.ErrorReport ).metadata
+      ErrorReport.new(metadata[OT.statusCode], metadata[OT.errorCode], metadata[OT.message], metadata[OT.actor], metadata[OT.errorCause])
+    end
+    
+    # overwrite sorting to make easier readable
+    def to_yaml_properties
+       p = super
+       p = ( p - ["@backtrace"]) + ["@backtrace"] if @backtrace
+       p = ( p - ["@errorCause"]) + ["@errorCause"] if @errorCause
+       p
+    end
+    
+    def rdf_content()
+      c = {
+        RDF.type => OT.ErrorReport,
+        OT.statusCode => @http_code,
+        OT.message => @message,
+        OT.actor => @actor,
+        OT.errorCode => @errorType,
+      }
+      c[OT.errorCause] = @errorCause.rdf_content if @errorCause
+      c
+    end
+    
+    def to_rdfxml
+      s = Serializer::Owl.new
+      s.add_resource(CONFIG[:services]["opentox-task"]+"/tmpId/ErrorReport/tmpId", OT.errorReport, rdf_content)
+      s.to_rdfxml
+    end
+  end
+end
+
+class Array
+  def short_backtrace
+    short = []
+    each do |c|
+      break if c =~ /sinatra\/base/
+      short << c
+    end
+    short.join("\n")
+  end
+end

data/lib/feature.rb

@@ -2,14 +2,42 @@ module OpenTox
   class Feature
     include OpenTox
 
-    def self.find(uri)
+    def self.find(uri, subjectid=nil)
+      return nil unless uri   
       feature = Feature.new uri
       if (CONFIG[:yaml_hosts].include?(URI.parse(uri).host))
-        feature.add_metadata YAML.load(RestClientWrapper.get(uri,:accept => "application/x-yaml"))
+        feature.add_metadata YAML.load(RestClientWrapper.get(uri,{:accept => "application/x-yaml", :subjectid => subjectid}))
       else
         feature.add_metadata  Parser::Owl::Dataset.new(uri).load_metadata
       end
       feature
     end
+    
+    # provides domain (possible target values) of classification feature 
+    # @return [Array] list with possible target values
+    def domain
+      if metadata[OT.acceptValue]
+        raise "accept value found, remove hack and implement correctly"
+      else
+      if @uri=~/feature\/26221/ || @uri=~/feature\/221726/ 
+        return ["mutagen" , "nonmutagen"]
+      end
+        return [true, false]
+      end
+    end
+    
+    # provides feature type, possible types are "regression" or "classification"
+    # @return [String] feature type, unknown if OT.isA property is unknown/ not set
+    def feature_type
+      case metadata[OT.isA]
+      when /NominalFeature/
+        "classification"
+      when /NumericFeature/
+        "regression"
+      else
+        "unknown"
+      end
+    end    
+    
   end
 end