From 80c1821e3a55b0d9c1ee51537e109dff3bc79423 Mon Sep 17 00:00:00 2001 From: Christoph Helma Date: Tue, 16 Jul 2013 17:45:08 +0200 Subject: subjectid handled by RestClientWrapper --- lib/algorithm.rb | 2 +- lib/dataset.rb | 16 +++--- lib/opentox-client.rb | 8 +++ lib/opentox.rb | 40 ++++++++------ lib/overwrite.rb | 14 ++--- lib/rest-client-wrapper.rb | 12 +++- lib/task.rb | 10 ++-- lib/validation.rb | 135 ++++++++++++++++++--------------------------- 8 files changed, 118 insertions(+), 119 deletions(-) diff --git a/lib/algorithm.rb b/lib/algorithm.rb index a725141..036d345 100644 --- a/lib/algorithm.rb +++ b/lib/algorithm.rb @@ -9,7 +9,7 @@ module OpenTox # @param [optional,Boolean] wait set to false if method should return a task uri instead of the algorithm result # @return [String] URI of new resource (dataset, model, ...) def run params=nil, wait=true - uri = RestClientWrapper.post @uri, params, { :content_type => "text/uri-list", :subjectid => SUBJECTID} + uri = RestClientWrapper.post @uri, params, { :content_type => "text/uri-list"} wait_for_task uri if wait end diff --git a/lib/dataset.rb b/lib/dataset.rb index cb64406..4fad05b 100644 --- a/lib/dataset.rb +++ b/lib/dataset.rb @@ -7,8 +7,8 @@ module OpenTox attr_writer :features, :compounds, :data_entries - def initialize uri=nil, subjectid=SUBJECTID - super uri, subjectid + def initialize uri=nil + super uri @features = [] @compounds = [] @data_entries = [] @@ -21,9 +21,9 @@ module OpenTox if @metadata.empty? or force_update uri = File.join(@uri,"metadata") begin - parse_ntriples RestClientWrapper.get(uri,{},{:accept => "text/plain", :subjectid => @subjectid}) + parse_ntriples RestClientWrapper.get(uri,{},{:accept => "text/plain"}) rescue # fall back to rdfxml - parse_rdfxml RestClientWrapper.get(uri,{},{:accept => "application/rdf+xml", :subjectid => @subjectid}) + parse_rdfxml RestClientWrapper.get(uri,{},{:accept => "application/rdf+xml"}) end @metadata = @rdf.to_hash[RDF::URI.new(@uri)].inject({}) { |h, (predicate, values)| h[predicate] = values.collect{|v| v.to_s}; h } end @@ -34,7 +34,7 @@ module OpenTox def features force_update=false if @features.empty? or force_update uri = File.join(@uri,"features") - uris = RestClientWrapper.get(uri,{},{:accept => "text/uri-list", :subjectid => @subjectid}).split("\n") # ordered datasets return ordered features + uris = RestClientWrapper.get(uri,{},{:accept => "text/uri-list"}).split("\n") # ordered datasets return ordered features @features = uris.collect{|uri| Feature.new(uri)} end @features @@ -44,7 +44,7 @@ module OpenTox def compounds force_update=false if @compounds.empty? or force_update uri = File.join(@uri,"compounds") - uris = RestClientWrapper.get(uri,{},{:accept => "text/uri-list", :subjectid => @subjectid}).split("\n") # ordered datasets return ordered compounds + uris = RestClientWrapper.get(uri,{},{:accept => "text/uri-list"}).split("\n") # ordered datasets return ordered compounds @compounds = uris.collect{|uri| Compound.new(uri)} end @compounds @@ -61,7 +61,7 @@ module OpenTox <#{RDF::OT.value}> ?value . ?f <#{RDF::OLO.index}> ?fidx. } ORDER BY ?fidx ?cidx" - RestClientWrapper.get(service_uri,{:query => sparql},{:accept => "text/uri-list", :subjectid => @subjectid}).split("\n").each do |row| + RestClientWrapper.get(service_uri,{:query => sparql},{:accept => "text/uri-list"}).split("\n").each do |row| r,c,v = row.split("\t") @data_entries[r.to_i] ||= [] # adjust value class depending on feature type, StringFeature takes precedence over NumericFeature @@ -135,7 +135,7 @@ module OpenTox # @param filename [String] # @return [String] dataset uri def upload filename, wait=true - uri = RestClientWrapper.put(@uri, {:file => File.new(filename)}, {:subjectid => @subjectid}) + uri = RestClientWrapper.put(@uri, {:file => File.new(filename)}) wait_for_task uri if URI.task?(uri) and wait compounds true features true diff --git a/lib/opentox-client.rb b/lib/opentox-client.rb index 77c6eae..8683d0f 100644 --- a/lib/opentox-client.rb +++ b/lib/opentox-client.rb @@ -50,6 +50,13 @@ FALSE_REGEXP = /^(false|inactive|0|0.0|low tox|deactivating|non-carcinogen|non-m "validation.rb" ].each{ |f| require_relative f } +if defined?($aa) and $aa[:uri] + OpenTox::RestClientWrapper.subjectid = OpenTox::Authorization.authenticate($aa[:user],$aa[:password]) + unauthorized_error "Failed to authenticate user \"#{$aa[:user]}\"." unless OpenTox::Authorization.is_token_valid(OpenTox::RestClientWrapper.subjectid) +#else + #@@subjectid = nil +end +=begin module OpenTox if defined?($aa) and $aa[:uri] SUBJECTID = OpenTox::Authorization.authenticate($aa[:user],$aa[:password]) @@ -58,4 +65,5 @@ module OpenTox SUBJECTID = nil end end +=end diff --git a/lib/opentox.rb b/lib/opentox.rb index 73a33d3..87b241a 100644 --- a/lib/opentox.rb +++ b/lib/opentox.rb @@ -5,7 +5,7 @@ $logger.level = Logger::DEBUG module OpenTox #include RDF CH: leads to namespace clashes with URI class - attr_reader :uri, :subjectid + attr_reader :uri attr_writer :metadata, :parameters # Ruby interface @@ -13,7 +13,7 @@ module OpenTox # Create a new OpenTox object # @param uri [optional,String] URI # @return [OpenTox] OpenTox object - def initialize uri=nil, subjectid=SUBJECTID + def initialize uri=nil @rdf = RDF::Graph.new @metadata = {} @parameters = [] @@ -79,10 +79,10 @@ module OpenTox # @param [String,optional] mime_type def get mime_type="text/plain" bad_request_error "Mime type #{mime_type} is not supported. Please use 'text/plain' (default) or 'application/rdf+xml'." unless mime_type == "text/plain" or mime_type == "application/rdf+xml" - response = RestClientWrapper.get(@uri,{},{:accept => mime_type,:subjectid => @subjectid}) + response = RestClientWrapper.get(@uri,{},{:accept => mime_type}) if URI.task?(response) uri = wait_for_task response - response = RestClientWrapper.get(uri,{},{:accept => mime_type,:subjectid => @subjectid}) + response = RestClientWrapper.get(uri,{},{:accept => mime_type}) end parse_ntriples response if mime_type == "text/plain" parse_rdfxml response if mime_type == "application/rdf+xml" @@ -98,8 +98,8 @@ module OpenTox when 'application/rdf+xml' body = self.to_rdfxml end - Authorization.check_policy(@uri, SUBJECTID) if $aa[:uri] - uri = RestClientWrapper.post @uri.to_s, body, { :content_type => mime_type,:subjectid => @subjectid} + Authorization.check_policy(@uri, RestClientWrapper.subjectid) if $aa[:uri] + uri = RestClientWrapper.post @uri.to_s, body, { :content_type => mime_type} wait ? wait_for_task(uri) : uri end @@ -114,14 +114,14 @@ module OpenTox when 'application/rdf+xml' body = self.to_rdfxml end - uri = RestClientWrapper.put @uri.to_s, body, { :content_type => mime_type,:subjectid => @subjectid} + uri = RestClientWrapper.put @uri, body, { :content_type => mime_type} wait ? wait_for_task(uri) : uri end # Delete object at webservice def delete - RestClientWrapper.delete(@uri.to_s,{},{:subjectid => @subjectid}) - Authorization.delete_policies_from_uri(@uri, SUBJECTID) if $aa[:uri] + RestClientWrapper.delete(@uri) + Authorization.delete_policies_from_uri(@uri, RestClientWrapper.subjectid) if $aa[:uri] end def service_uri @@ -200,6 +200,12 @@ module OpenTox rescue bad_request_error "$#{service}[:uri] variable not set. Please set $#{service}[:uri] or use an explicit uri as first constructor argument " end + def subjectid + RestClientWrapper.subjectid + end + def subjectid=(subjectid) + RestClientWrapper.subjectid = subjectid + end end # create default OpenTox classes with class methods @@ -209,24 +215,24 @@ module OpenTox include OpenTox def self.all - uris = RestClientWrapper.get(service_uri, {},{:accept => 'text/uri-list',:subjectid=>@subjectid}).split("\n").compact + uris = RestClientWrapper.get(service_uri, {},{:accept => 'text/uri-list'}).split("\n").compact uris.collect{|uri| self.new(uri)} end #@example fetching a model # OpenTox::Model.find() -> model-object - def self.find uri, subjectid=SUBJECTID + def self.find uri URI.accessible?(uri) ? self.new(uri) : nil end - def self.create metadata, subjectid=SUBJECTID - object = self.new nil, subjectid + def self.create metadata + object = self.new object.metadata = metadata object.put object end - def self.find_or_create metadata, subjectid=SUBJECTID + def self.find_or_create metadata sparql = "SELECT DISTINCT ?s WHERE { " metadata.each do |predicate,objects| unless [RDF::DC.date,RDF::DC.modified,RDF::DC.description].include? predicate # remove dates and description (strange characters in description may lead to SPARQL errors) @@ -242,11 +248,11 @@ module OpenTox end end sparql << "}" - uris = RestClientWrapper.get(service_uri,{:query => sparql},{:accept => "text/uri-list",:subjectid=>subjectid}).split("\n") + uris = RestClientWrapper.get(service_uri,{:query => sparql},{:accept => "text/uri-list"}).split("\n") if uris.empty? - self.create metadata, subjectid + self.create metadata else - self.new uris.first, subjectid + self.new uris.first end end end diff --git a/lib/overwrite.rb b/lib/overwrite.rb index c6bf02a..ff43347 100644 --- a/lib/overwrite.rb +++ b/lib/overwrite.rb @@ -84,21 +84,21 @@ module URI uri =~ /task/ and URI.valid? uri end - def self.dataset? uri, subjectid=OpenTox::SUBJECTID - uri =~ /dataset/ and URI.accessible? uri, subjectid + def self.dataset? uri + uri =~ /dataset/ and URI.accessible? uri end - def self.model? uri, subjectid=OpenTox::SUBJECTID - uri =~ /model/ and URI.accessible? uri, subjectid + def self.model? uri + uri =~ /model/ and URI.accessible? uri end - def self.ssl? uri, subjectid=OpenTox::SUBJECTID + def self.ssl? uri URI.parse(uri).instance_of? URI::HTTPS end # @return [Boolean] checks if resource exists by making a HEAD-request - def self.accessible?(uri, subjectid=OpenTox::SUBJECTID) - parsed_uri = URI.parse(uri + (subjectid ? "?subjectid=#{CGI.escape subjectid}" : "")) + def self.accessible?(uri) + parsed_uri = URI.parse(uri + (OpenTox::RestClientWrapper.subjectid ? "?subjectid=#{CGI.escape OpenTox::RestClientWrapper.subjectid}" : "")) http_code = URI.task?(uri) ? 600 : 400 http = Net::HTTP.new(parsed_uri.host, parsed_uri.port) unless (URI.ssl? uri) == true diff --git a/lib/rest-client-wrapper.rb b/lib/rest-client-wrapper.rb index 2de9377..134dd32 100644 --- a/lib/rest-client-wrapper.rb +++ b/lib/rest-client-wrapper.rb @@ -4,6 +4,16 @@ module OpenTox attr_accessor :request, :response + @@subjectid = nil + + def self.subjectid=(subjectid) + @@subjectid = subjectid + end + + def self.subjectid + @@subjectid + end + # REST methods # Raises OpenTox::Error if call fails (rescued in overwrite.rb -> halt 502) # Does not wait for task to finish and returns task uri @@ -17,7 +27,7 @@ module OpenTox # check input bad_request_error "Headers are not a hash: #{headers.inspect}", uri unless headers==nil or headers.is_a?(Hash) - headers[:subjectid] ||= OpenTox::SUBJECTID + headers[:subjectid] ||= @@subjectid bad_request_error "Invalid URI: '#{uri}'", uri unless URI.valid? uri #resource_not_found_error "URI '#{uri}' not found.", uri unless URI.accessible?(uri, @subjectid) unless URI.ssl?(uri) # make sure that no header parameters are set in the payload diff --git a/lib/task.rb b/lib/task.rb index d642f48..07efc0f 100644 --- a/lib/task.rb +++ b/lib/task.rb @@ -10,9 +10,9 @@ module OpenTox super true # always update metadata end - def self.run(description, creator=nil, subjectid=SUBJECTID) + def self.run(description, creator=nil) - task = Task.new nil, subjectid + task = Task.new nil task[RDF::OT.created_at] = DateTime.now task[RDF::OT.hasStatus] = "Running" task[RDF::DC.description] = description.to_s @@ -23,7 +23,7 @@ module OpenTox task.completed yield rescue if $!.respond_to? :to_ntriples - RestClientWrapper.put(File.join(task.uri,'Error'),{:errorReport => $!.to_ntriples},{:content_type => 'text/plain', :subjectid => task.subjectid}) + RestClientWrapper.put(File.join(task.uri,'Error'),{:errorReport => $!.to_ntriples},{:content_type => 'text/plain'}) else cut_index = $!.backtrace.find_index{|line| line.match /gems\/sinatra/} cut_index = -1 unless cut_index @@ -41,7 +41,7 @@ module OpenTox nt = RDF::Writer.for(:ntriples).buffer do |writer| @rdf.each{|statement| writer << statement} end - RestClientWrapper.put(File.join(task.uri,'Error'),{:errorReport => nt},{:content_type => 'text/plain', :subjectid => task.subjectid}) + RestClientWrapper.put(File.join(task.uri,'Error'),{:errorReport => nt},{:content_type => 'text/plain'}) end task.kill end @@ -107,7 +107,7 @@ module OpenTox end def code - RestClientWrapper.head(@uri,{},:subjectid => @subjectid).code.to_i + RestClientWrapper.head(@uri).code.to_i end # get only header for status requests diff --git a/lib/validation.rb b/lib/validation.rb index 565a366..997f814 100644 --- a/lib/validation.rb +++ b/lib/validation.rb @@ -9,13 +9,13 @@ module OldOpenTox end # loads metadata via yaml - def load_metadata( subjectid=nil ) - yaml = OpenTox::RestClientWrapper.get(uri,nil,{:subjectid => subjectid, :accept => "application/x-yaml"}) + def load_metadata + yaml = OpenTox::RestClientWrapper.get(uri,nil,{:accept => "application/x-yaml"}) @metadata = YAML.load(yaml) end - def delete (subjectid=nil) - OpenTox::RestClientWrapper.delete(@uri.to_s,nil,{:subjectid => subjectid}) + def delete + OpenTox::RestClientWrapper.delete @uri.to_s end end @@ -26,80 +26,71 @@ module OpenTox # find validation, raises error if not found # @param [String] uri - # @param [String,optional] subjectid # @return [OpenTox::Validation] - def self.find( uri, subjectid=nil ) + def self.find( uri ) val = Validation.new(uri) - val.load_metadata( subjectid ) + val.load_metadata val end # returns a filtered list of validation uris # @param params [Hash,optional] validation-params to filter the uris (could be model, training_dataset, ..) # @return [Array] - def self.list( params={}, subjectid=nil ) + def self.list( params={} ) filter_string = "" params.each do |k,v| filter_string += (filter_string.length==0 ? "?" : "&") v = v.to_s.gsub(/;/, "%3b") if v.to_s =~ /;/ filter_string += k.to_s+"="+v.to_s end - (OpenTox::RestClientWrapper.get($validation[:uri]+filter_string,nil,{:subjectid => subjectid}).split("\n")) + (OpenTox::RestClientWrapper.get($validation[:uri]+filter_string).split("\n")) end # creates a training test split validation, waits until it finishes, may take some time # @param [Hash] params (required:algorithm_uri,dataset_uri,prediction_feature, optional:algorithm_params,split_ratio(0.67),random_seed(1)) - # @param [String,optional] subjectid # @param [OpenTox::Task,optional] waiting_task (can be a OpenTox::Subtask as well), progress is updated accordingly # @return [OpenTox::Validation] - def self.create_training_test_split( params, subjectid=nil, waiting_task=nil ) - #params[:subjectid] = subjectid if subjectid + def self.create_training_test_split( params, waiting_task=nil ) uri = OpenTox::RestClientWrapper.post( File.join($validation[:uri],"training_test_split"), - params,{:content_type => "text/uri-list", :subjectid => subjectid},waiting_task ) + params,{:content_type => "text/uri-list"},waiting_task ) Validation.new(wait_for_task(uri)) end # creates a training test validation, waits until it finishes, may take some time # @param [Hash] params (required:algorithm_uri,training_dataset_uri,prediction_feature,test_dataset_uri,optional:algorithm_params) - # @param [String,optional] subjectid # @param [OpenTox::Task,optional] waiting_task (can be a OpenTox::Subtask as well), progress is updated accordingly # @return [OpenTox::Validation] - def self.create_training_test_validation( params, subjectid=nil, waiting_task=nil ) - params[:subjectid] = subjectid if subjectid + def self.create_training_test_validation( params, waiting_task=nil ) uri = OpenTox::RestClientWrapper.post( File.join($validation[:uri],"training_test_validation"), - params,{:content_type => "text/uri-list", :subjectid => subjectid},waiting_task ) + params,{:content_type => "text/uri-list"},waiting_task ) Validation.new(wait_for_task(uri)) end # creates a bootstrapping validation, waits until it finishes, may take some time # @param [Hash] params (required:algorithm_uri,dataset_uri,prediction_feature, optional:algorithm_params,random_seed(1)) - # @param [String,optional] subjectid # @param [OpenTox::Task,optional] waiting_task (can be a OpenTox::Subtask as well), progress is updated accordingly # @return [OpenTox::Validation] - def self.create_bootstrapping_validation( params, subjectid=nil, waiting_task=nil ) - params[:subjectid] = subjectid if subjectid + def self.create_bootstrapping_validation( params, waiting_task=nil ) uri = OpenTox::RestClientWrapper.post( File.join($validation[:uri],"bootstrapping"), - params,{:content_type => "text/uri-list", :subjectid => subjectid},waiting_task ) + params,{:content_type => "text/uri-list"},waiting_task ) Validation.new(wait_for_task(uri)) end # looks for report for this validation, creates a report if no report is found - # @param [String,optional] subjectid # @param [OpenTox::Task,optional] waiting_task (can be a OpenTox::Subtask as well), progress is updated accordingly # @return [String] report uri - def find_or_create_report( subjectid=nil, waiting_task=nil ) - @report = ValidationReport.find_for_validation(@uri, subjectid) unless @report - @report = ValidationReport.create(@uri, {}, subjectid, waiting_task) unless @report + def find_or_create_report( waiting_task=nil ) + @report = ValidationReport.find_for_validation(@uri) unless @report + @report = ValidationReport.create(@uri, waiting_task) unless @report @report.uri end # creates a validation object from crossvaldiation statistics, raise error if not found # (as crossvaldiation statistics are returned as an average valdidation over all folds) # @param crossvalidation_uri [String] crossvalidation uri - # @param [String,optional] subjectid # @return [OpenTox::Validation] - def self.from_cv_statistics( crossvalidation_uri, subjectid=nil ) - find( File.join(crossvalidation_uri, 'statistics'),subjectid ) + def self.from_cv_statistics( crossvalidation_uri ) + find( File.join(crossvalidation_uri, 'statistics') ) end # returns confusion matrix as array, predicted values are in rows @@ -131,7 +122,6 @@ module OpenTox # # @param confidence [Float] confidence value (between 0 and 1) # @param prediction [String] predicted value - # @param subjectid [String,optional] # @return [Hash] see example # @example # Example 1: @@ -145,9 +135,9 @@ module OpenTox # the given confidence value was to high (i.e. <12 predictions with confidence value >= 0.8) # the top 12 "active" predictions have a min_confidence of 0.45, 90 percent of them beeing correct # - def probabilities( confidence, prediction, subjectid=nil ) + def probabilities( confidence, prediction ) YAML.load(OpenTox::RestClientWrapper.get(@uri+"/probabilities?prediction="+prediction.to_s+"&confidence="+confidence.to_s,nil, - {:subjectid => subjectid, :accept => "application/x-yaml"})) + {:accept => "application/x-yaml"})) end end @@ -158,11 +148,10 @@ module OpenTox # find crossvalidation, raises error if not found # @param [String] uri - # @param [String,optional] subjectid # @return [OpenTox::Crossvalidation] - def self.find( uri, subjectid=nil ) + def self.find( uri ) cv = Crossvalidation.new(uri) - cv.load_metadata( subjectid ) + cv.load_metadata cv end @@ -181,42 +170,39 @@ module OpenTox # creates a crossvalidations, waits until it finishes, may take some time # @param [Hash] params (required:algorithm_uri,dataset_uri,prediction_feature, optional:algorithm_params,num_folds(10),random_seed(1),stratified(false)) - # @param [String,optional] subjectid # @param [OpenTox::Task,optional] waiting_task (can be a OpenTox::Subtask as well), progress is updated accordingly # @return [OpenTox::Crossvalidation] - def self.create( params, subjectid=nil, waiting_task=nil ) - #params[:subjectid] = subjectid if subjectid + def self.create( params, waiting_task=nil ) uri = OpenTox::RestClientWrapper.post( File.join($validation[:uri],"crossvalidation"), - params,{:content_type => "text/uri-list", :subjectid => subjectid},waiting_task ) + params,{:content_type => "text/uri-list"},waiting_task ) uri = wait_for_task(uri) Crossvalidation.new(uri) end # looks for report for this crossvalidation, creates a report if no report is found - # @param [String,optional] subjectid # @param [OpenTox::Task,optional] waiting_task (can be a OpenTox::Subtask as well), progress is updated accordingly # @return [String] report uri - def find_or_create_report( subjectid=nil, waiting_task=nil ) - @report = CrossvalidationReport.find_for_crossvalidation(@uri, subjectid) unless @report - @report = CrossvalidationReport.create(@uri, subjectid, waiting_task) unless @report + def find_or_create_report( waiting_task=nil ) + @report = CrossvalidationReport.find_for_crossvalidation(@uri) unless @report + @report = CrossvalidationReport.create(@uri, waiting_task) unless @report @report.uri end # loads metadata via yaml from crossvalidation object # fields (like for example the validations) can be acces via validation.metadata[RDF::OT.validation] - def load_metadata( subjectid=nil ) - @metadata = YAML.load(OpenTox::RestClientWrapper.get(uri,nil,{:subjectid => subjectid, :accept => "application/x-yaml"})) + def load_metadata + @metadata = YAML.load(OpenTox::RestClientWrapper.get(uri,nil,{:accept => "application/x-yaml"})) end # returns a Validation object containing the statistics of the crossavlidation - def statistics( subjectid=nil ) - Validation.from_cv_statistics( @uri, subjectid ) + def statistics + Validation.from_cv_statistics( @uri ) end # documentation see OpenTox::Validation.probabilities - def probabilities( confidence, prediction, subjectid=nil ) + def probabilities( confidence, prediction ) YAML.load(OpenTox::RestClientWrapper.get(@uri+"/statistics/probabilities?prediction="+prediction.to_s+"&confidence="+confidence.to_s,nil, - {:subjectid => subjectid, :accept => "application/x-yaml"})) + {:accept => "application/x-yaml"})) end end @@ -226,22 +212,20 @@ module OpenTox # finds ValidationReport via uri, raises error if not found # @param [String] uri - # @param [String,optional] subjectid # @return [OpenTox::ValidationReport] - def self.find( uri, subjectid=nil ) - OpenTox::RestClientWrapper.get(uri,nil,{:subjectid => subjectid}) + def self.find( uri ) + OpenTox::RestClientWrapper.get(uri) rep = ValidationReport.new(uri) - rep.load_metadata( subjectid ) + rep.load_metadata rep end # finds ValidationReport for a particular validation # @param validation_uri [String] crossvalidation uri - # @param subjectid [String,optional] # @return [OpenTox::ValidationReport] nil if no report found - def self.find_for_validation( validation_uri, subjectid=nil ) + def self.find_for_validation( validation_uri ) uris = RestClientWrapper.get(File.join($validation[:uri], - "/report/validation?validation="+validation_uri),nil,{:subjectid => subjectid}).chomp.split("\n") + "/report/validation?validation="+validation_uri)).chomp.split("\n") uris.size==0 ? nil : ValidationReport.new(uris[-1]) end @@ -249,16 +233,14 @@ module OpenTox # @param validation_uri [String] validation uri # @param params [Hash] params addiditonal possible # (min_confidence, params={}, min_num_predictions, max_num_predictions) - # @param subjectid [String,optional] # @param waiting_task [OpenTox::Task,optional] (can be a OpenTox::Subtask as well), progress is updated accordingly # @return [OpenTox::ValidationReport] - def self.create( validation_uri, params={}, subjectid=nil, waiting_task=nil ) + def self.create( validation_uri, params={}, waiting_task=nil ) params = {} if params==nil bad_request_error "params is no hash" unless params.is_a?(Hash) params[:validation_uris] = validation_uri - params[:subjectid] = subjectid uri = RestClientWrapper.post(File.join($validation[:uri],"/report/validation"), - params, {:subjectid => subjectid}, waiting_task ) + params, {}, waiting_task ) uri = wait_for_task(uri) ValidationReport.new(uri) end @@ -270,33 +252,30 @@ module OpenTox # finds CrossvalidationReport via uri, raises error if not found # @param [String] uri - # @param [String,optional] subjectid # @return [OpenTox::CrossvalidationReport] - def self.find( uri, subjectid=nil ) - OpenTox::RestClientWrapper.get(uri,nil,{:subjectid => subjectid}) + def self.find( uri ) + OpenTox::RestClientWrapper.get(uri) rep = CrossvalidationReport.new(uri) - rep.load_metadata( subjectid ) + rep.load_metadata rep end # finds CrossvalidationReport for a particular crossvalidation # @param crossvalidation_uri [String] crossvalidation uri - # @param subjectid [String,optional] # @return [OpenTox::CrossvalidationReport] nil if no report found - def self.find_for_crossvalidation( crossvalidation_uri, subjectid=nil ) + def self.find_for_crossvalidation( crossvalidation_uri ) uris = RestClientWrapper.get(File.join($validation[:uri], - "/report/crossvalidation?crossvalidation="+crossvalidation_uri),nil,{:subjectid => subjectid}).chomp.split("\n") + "/report/crossvalidation?crossvalidation="+crossvalidation_uri)).chomp.split("\n") uris.size==0 ? nil : CrossvalidationReport.new(uris[-1]) end # creates a crossvalidation report via crossvalidation # @param crossvalidation_uri [String] crossvalidation uri - # @param subjectid [String,optional] # @param waiting_task [OpenTox::Task,optional] (can be a OpenTox::Subtask as well), progress is updated accordingly # @return [OpenTox::CrossvalidationReport] - def self.create( crossvalidation_uri, subjectid=nil, waiting_task=nil ) + def self.create( crossvalidation_uri, waiting_task=nil ) uri = RestClientWrapper.post(File.join($validation[:uri],"/report/crossvalidation"), - { :validation_uris => crossvalidation_uri, :subjectid => subjectid }, {}, waiting_task ) + { :validation_uris => crossvalidation_uri }, {}, waiting_task ) uri = wait_for_task(uri) CrossvalidationReport.new(uri) end @@ -308,22 +287,20 @@ module OpenTox # finds AlgorithmComparisonReport via uri, raises error if not found # @param [String] uri - # @param [String,optional] subjectid # @return [OpenTox::CrossvalidationReport] - def self.find( uri, subjectid=nil ) - OpenTox::RestClientWrapper.get(uri,nil,{:subjectid => subjectid}) + def self.find( uri ) + OpenTox::RestClientWrapper.get(uri) rep = AlgorithmComparisonReport.new(uri) - rep.load_metadata( subjectid ) + rep.load_metadata rep end # finds AlgorithmComparisonReport for a particular crossvalidation # @param crossvalidation_uri [String] crossvalidation uri - # @param subjectid [String,optional] # @return [OpenTox::AlgorithmComparisonReport] nil if no report found - def self.find_for_crossvalidation( crossvalidation_uri, subjectid=nil ) + def self.find_for_crossvalidation( crossvalidation_uri ) uris = RestClientWrapper.get(File.join($validation[:uri], - "/report/algorithm_comparison?crossvalidation="+crossvalidation_uri),nil,{:subjectid => subjectid}).chomp.split("\n") + "/report/algorithm_comparison?crossvalidation="+crossvalidation_uri)).chomp.split("\n") uris.size==0 ? nil : AlgorithmComparisonReport.new(uris[-1]) end @@ -331,13 +308,12 @@ module OpenTox # @param crossvalidation_uri_hash [Hash] crossvalidation uri_hash, see example # @param params [Hash] params addiditonal possible # (ttest_significance, ttest_attributes, min_confidence, min_num_predictions, max_num_predictions) - # @param subjectid [String,optional] # @param waiting_task [OpenTox::Task,optional] (can be a OpenTox::Subtask as well), progress is updated accordingly # @return [OpenTox::AlgorithmComparisonReport] # example for hash: # { :lazar-bbrc => [ http://host/validation/crossvalidation/x1, http://host/validation/crossvalidation/x2 ], # :lazar-last => [ http://host/validation/crossvalidation/xy, http://host/validation/crossvalidation/xy ] } - def self.create( crossvalidation_uri_hash, params={}, subjectid=nil, waiting_task=nil ) + def self.create( crossvalidation_uri_hash, params={}, waiting_task=nil ) identifier = [] validation_uris = [] crossvalidation_uri_hash.each do |id, uris| @@ -350,8 +326,7 @@ module OpenTox raise OpenTox::BadRequestError.new "params is no hash" unless params.is_a?(Hash) params[:validation_uris] = validation_uris.join(",") params[:identifier] = identifier.join(",") - params[:subjectid] = subjectid - uri = RestClientWrapper.post(File.join($validation[:uri],"/report/algorithm_comparison"), params, {:subjectid => subjectid}, waiting_task ) + uri = RestClientWrapper.post(File.join($validation[:uri],"/report/algorithm_comparison"), params, waiting_task ) uri = wait_for_task(uri) AlgorithmComparisonReport.new(uri) end -- cgit v1.2.3