subjectid handled by RestClientWrapper

6 files changed, 37 insertions, 37 deletions

diff --git a/descriptor.rb b/descriptor.rb
index 493d6cd..c3756f2 100644
--- a/descriptor.rb
+++ b/descriptor.rb
@@ -9,7 +9,7 @@ module OpenTox
 
     before '/descriptor/:method/?' do
       if request.get?
-        @algorithm = OpenTox::Algorithm::Descriptor.new @uri, @subjectid
+        @algorithm = OpenTox::Algorithm::Descriptor.new @uri
         @algorithm.parameters = [ {
           RDF::DC.description => "Dataset URI", 
           RDF::OT.paramScope => "optional", 
@@ -90,10 +90,10 @@ module OpenTox
         result = OpenTox::Algorithm::Descriptor.send(params[:method].to_sym, @compounds, params[:descriptors])
         Hash[result.map {|compound, v| [compound.uri, v] }].to_json
       elsif params[:dataset_uri] # return dataset
-        task = OpenTox::Task.run("Calculating #{params[:method]} descriptors for dataset #{params[:dataset_uri]}.", @uri, @subjectid) do |task|
-          @compounds = OpenTox::Dataset.new(params[:dataset_uri],@subjectid).compounds
+        task = OpenTox::Task.run("Calculating #{params[:method]} descriptors for dataset #{params[:dataset_uri]}.", @uri) do |task|
+          @compounds = OpenTox::Dataset.new(params[:dataset_uri]).compounds
           result = OpenTox::Algorithm::Descriptor.send(params[:method].to_sym, @compounds, params[:descriptors])
-          dataset = OpenTox::Dataset.new nil, @subjectid
+          dataset = OpenTox::Dataset.new
           dataset.metadata = {
             RDF::DC.title => "Physico-chemical descriptors",
             RDF::DC.creator => @uri,
diff --git a/fminer.rb b/fminer.rb
index e9a6f73..dd25fd2 100644
--- a/fminer.rb
+++ b/fminer.rb
@@ -27,7 +27,7 @@ module OpenTox
     # Get representation of BBRC algorithm
     # @return [String] Representation
     get "/fminer/bbrc/?" do
-      algorithm = OpenTox::Algorithm::Generic.new(to('/fminer/bbrc',:full), @subjectid)
+      algorithm = OpenTox::Algorithm::Generic.new(to('/fminer/bbrc',:full))
       algorithm.metadata = {
         RDF::DC.title => 'Backbone Refinement Class Representatives',
         RDF::DC.creator => "andreas@maunz.de",
@@ -49,7 +49,7 @@ module OpenTox
     # Get representation of BBRC-sample algorithm
     # @return [String] Representation
     get "/fminer/bbrc/sample/?" do
-      algorithm = OpenTox::Algorithm::Generic.new(to('/fminer/bbrc/sample',:full), @subjectid)
+      algorithm = OpenTox::Algorithm::Generic.new(to('/fminer/bbrc/sample',:full))
       algorithm.metadata = {
         RDF::DC.title => 'Backbone Refinement Class Representatives, obtained from samples of a dataset',
         RDF::DC.creator => "andreas@maunz.de",
@@ -71,7 +71,7 @@ module OpenTox
     # Get representation of fminer LAST-PM algorithm
     # @return [String] Representation
     get "/fminer/last/?" do
-      algorithm = OpenTox::Algorithm::Generic.new(to('/fminer/last',:full), @subjectid)
+      algorithm = OpenTox::Algorithm::Generic.new(to('/fminer/last',:full))
       algorithm.metadata = {
         RDF::DC.title => 'Latent Structure Pattern Mining descriptors',
         RDF::DC.creator => "andreas@maunz.de",
@@ -92,7 +92,7 @@ module OpenTox
     # Get representation of matching algorithm
     # @return [String] Representation
     get "/fminer/:method/match?" do
-      algorithm = OpenTox::Algorithm::Generic.new(to("/fminer/#{params[:method]}/match",:full), @subjectid)
+      algorithm = OpenTox::Algorithm::Generic.new(to("/fminer/#{params[:method]}/match",:full))
       algorithm.metadata = {
         RDF::DC.title => 'fminer feature matching',
         RDF::DC.creator => "mguetlein@gmail.com, andreas@maunz.de",
@@ -121,10 +121,10 @@ module OpenTox
     # @return [text/uri-list] Task URI
     post '/fminer/bbrc/?' do
     
-      @@fminer=OpenTox::Algorithm::Fminer.new(to('/fminer/bbrc',:full), @subjectid)
+      @@fminer=OpenTox::Algorithm::Fminer.new(to('/fminer/bbrc',:full))
       @@fminer.check_params(params,5)
     
-      task = OpenTox::Task.run("Mining BBRC features", uri('/fminer/bbrc'), @subjectid) do |task|
+      task = OpenTox::Task.run("Mining BBRC features", uri('/fminer/bbrc')) do |task|
 
         @@bbrc.Reset
         if @@fminer.prediction_feature.feature_type == "regression"
@@ -142,7 +142,7 @@ module OpenTox
         @@bbrc.SetChisqSig(params[:min_chisq_significance].to_f) if params[:min_chisq_significance]
         @@bbrc.SetConsoleOut(false)
 
-        feature_dataset = OpenTox::Dataset.new(nil, @subjectid)
+        feature_dataset = OpenTox::Dataset.new
         feature_dataset.metadata = {
           RDF::DC.title => "BBRC representatives",
           RDF::DC.creator => to('/fminer/bbrc',:full),
@@ -212,7 +212,7 @@ module OpenTox
                 RDF::OT.smarts => smarts.dup,
                 RDF::OT.pValue => p_value.to_f.abs.round(5),
                 RDF::OT.effect => effect
-              }, @subjectid)
+              })
               features << feature
             end
 
@@ -277,10 +277,10 @@ module OpenTox
     # @return [text/uri-list] Task URI
     post '/fminer/last/?' do
     
-      @@fminer=OpenTox::Algorithm::Fminer.new(to('/fminer/last',:full), @subjectid)
+      @@fminer=OpenTox::Algorithm::Fminer.new(to('/fminer/last',:full))
       @@fminer.check_params(params,80)
     
-      task = OpenTox::Task.run("Mining LAST features", uri('/fminer/last'), @subjectid) do |task|
+      task = OpenTox::Task.run("Mining LAST features", uri('/fminer/last')) do |task|
 
         @@last.Reset
         if @@fminer.prediction_feature.feature_type == "regression"
@@ -297,7 +297,7 @@ module OpenTox
         @@last.SetConsoleOut(false)
   
   
-        feature_dataset = OpenTox::Dataset.new(nil, @subjectid)
+        feature_dataset = OpenTox::Dataset.new
         feature_dataset.metadata = {
           RDF::DC.title => "LAST representatives for " + @@fminer.training_dataset.metadata[RDF::DC.title].to_s,
           RDF::DC.creator => to('/fminer/last'),
@@ -341,7 +341,7 @@ module OpenTox
         matches.each do |smarts, ids|
           metadata, parameters = @@fminer.calc_metadata(smarts, ids, counts[smarts], @@last, nil, value_map, params)
           metadata[RDF::DC.title] = smarts.dup
-          feature = OpenTox::Feature.find_or_create(metadata, @subjectid)
+          feature = OpenTox::Feature.find_or_create(metadata)
           features << feature
           ids.each_with_index { |id,idx| 
             fminer_results[@@fminer.compounds[id]] || fminer_results[@@fminer.compounds[id]] = {}
diff --git a/lazar.rb b/lazar.rb
index 4cb57de..e042401 100644
--- a/lazar.rb
+++ b/lazar.rb
@@ -31,7 +31,7 @@ module OpenTox
       bad_request_error "Please provide a dataset_uri parameter." unless params[:dataset_uri]
       #resource_not_found_error "Dataset '#{params[:dataset_uri]}' not found." unless URI.accessible? params[:dataset_uri], @subjectid # wrong URI class
       bad_request_error "Please provide a feature_generation_uri parameter." unless params[:feature_generation_uri]
-      task = OpenTox::Task.run("Create lazar model", uri('/lazar'), @subjectid) do |task|
+      task = OpenTox::Task.run("Create lazar model", uri('/lazar')) do |task|
         OpenTox::Model::Lazar.create(params)
       end
       response['Content-Type'] = 'text/uri-list'
@@ -55,7 +55,7 @@ module OpenTox
     post '/lazar/predict/?' do 
       # pass parameters instead of model_uri, because model service is blocked by incoming call
 
-      task = OpenTox::Task.run("Apply lazar model",uri('/lazar/predict'), @subjectid) do |task|
+      task = OpenTox::Task.run("Apply lazar model",uri('/lazar/predict')) do |task|
         OpenTox::Model::Lazar.new(params[:model_uri]).predict(params).uri
       end
       response['Content-Type'] = 'text/uri-list'
diff --git a/lib/dataset.rb b/lib/dataset.rb
index a42356b..c72aea7 100644
--- a/lib/dataset.rb
+++ b/lib/dataset.rb
@@ -12,7 +12,7 @@ module OpenTox
     # @param [Hash] uri Compound URI, Feature URI
     # @return [Object] activity Database activity, or nil
     def database_activity(params)
-      f=Feature.new params[:prediction_feature_uri], @subjectid
+      f=Feature.new params[:prediction_feature_uri]
       db_act = values(Compound.new(params[:compound_uri]), f)
       if !db_act.empty?
         if f.feature_type == "classification"
diff --git a/lib/fminer.rb b/lib/fminer.rb
index 4cb3455..8023bdd 100644
--- a/lib/fminer.rb
+++ b/lib/fminer.rb
@@ -20,12 +20,12 @@ module OpenTox
       
       def check_params(params,per_mil)
         bad_request_error "Please submit a dataset_uri." unless params[:dataset_uri] and  !params[:dataset_uri].nil?
-        @training_dataset = OpenTox::Dataset.new "#{params[:dataset_uri]}", @subjectid
+        @training_dataset = OpenTox::Dataset.new "#{params[:dataset_uri]}"
         unless params[:prediction_feature] # try to read prediction_feature from dataset
           resource_not_found_error "Please provide a prediction_feature parameter" unless @training_dataset.features.size == 1
           params[:prediction_feature] = @training_dataset.features.first.uri
         end
-        @prediction_feature = OpenTox::Feature.find params[:prediction_feature], @subjectid
+        @prediction_feature = OpenTox::Feature.find params[:prediction_feature]
         resource_not_found_error "No feature '#{params[:prediction_feature]}' in dataset '#{params[:dataset_uri]}'" unless 
           @training_dataset.find_feature_uri( params[:prediction_feature] ) 
         unless params[:min_frequency].nil? 
diff --git a/lib/lazar.rb b/lib/lazar.rb
index f849a48..6ce19d8 100644
--- a/lib/lazar.rb
+++ b/lib/lazar.rb
@@ -20,9 +20,9 @@ module OpenTox
       # @param[Hash] REST parameters, as input by user
       def self.create params
         
-        lazar = OpenTox::Model::Lazar.new(File.join($model[:uri],SecureRandom.uuid), @subjectid)
+        lazar = OpenTox::Model::Lazar.new(File.join($model[:uri],SecureRandom.uuid))
 
-        training_dataset = OpenTox::Dataset.new(params[:dataset_uri], @subjectid) 
+        training_dataset = OpenTox::Dataset.new(params[:dataset_uri]) 
         lazar.parameters << {RDF::DC.title => "training_dataset_uri", RDF::OT.paramValue => training_dataset.uri}
 
         if params[:prediction_feature]
@@ -32,8 +32,8 @@ module OpenTox
           params[:prediction_feature] = training_dataset.features.first.uri
         end
         lazar[RDF::OT.trainingDataset] = training_dataset.uri
-        prediction_feature = OpenTox::Feature.new(params[:prediction_feature], @subjectid) 
-        predicted_variable = OpenTox::Feature.find_or_create({RDF::DC.title => "#{prediction_feature.title} prediction", RDF.type => [RDF::OT.Feature, prediction_feature[RDF.type]]}, @subjectid)
+        prediction_feature = OpenTox::Feature.new(params[:prediction_feature]) 
+        predicted_variable = OpenTox::Feature.find_or_create({RDF::DC.title => "#{prediction_feature.title} prediction", RDF.type => [RDF::OT.Feature, prediction_feature[RDF.type]]})
         lazar[RDF::DC.title] = prediction_feature.title 
         lazar.parameters << {RDF::DC.title => "prediction_feature_uri", RDF::OT.paramValue => prediction_feature.uri}
         lazar[RDF::OT.dependentVariables] = prediction_feature.uri
@@ -41,7 +41,7 @@ module OpenTox
         bad_request_error "Unknown prediction_algorithm #{params[:prediction_algorithm]}" if params[:prediction_algorithm] and !OpenTox::Algorithm::Neighbors.respond_to?(params[:prediction_algorithm])
         lazar.parameters << {RDF::DC.title => "prediction_algorithm", RDF::OT.paramValue => params[:prediction_algorithm]} if params[:prediction_algorithm]
 
-        confidence_feature = OpenTox::Feature.find_or_create({RDF::DC.title => "predicted_confidence", RDF.type => [RDF::OT.Feature, RDF::OT.NumericFeature]}, @subjectid)
+        confidence_feature = OpenTox::Feature.find_or_create({RDF::DC.title => "predicted_confidence", RDF.type => [RDF::OT.Feature, RDF::OT.NumericFeature]})
         lazar[RDF::OT.predictedVariables] = [ predicted_variable.uri, confidence_feature.uri ]
         case prediction_feature.feature_type
         when "classification"
@@ -77,12 +77,12 @@ module OpenTox
         lazar.parameters << {RDF::DC.title => "min_train_performance", RDF::OT.paramValue => 0.1} unless lazar.parameter_value("min_train_performance")
 
         if params[:feature_dataset_uri]
-          bad_request_error "Feature dataset #{params[:feature_dataset_uri]} does not exist." unless URI.accessible? params[:feature_dataset_uri], @subjectid
+          bad_request_error "Feature dataset #{params[:feature_dataset_uri]} does not exist." unless URI.accessible? params[:feature_dataset_uri]
           lazar.parameters << {RDF::DC.title => "feature_dataset_uri", RDF::OT.paramValue => params[:feature_dataset_uri]}
           lazar[RDF::OT.featureDataset] = params["feature_dataset_uri"]
         else
           # run feature generation algorithm
-          feature_dataset_uri = OpenTox::Algorithm::Generic.new(params[:feature_generation_uri], @subjectid).run(params)
+          feature_dataset_uri = OpenTox::Algorithm::Generic.new(params[:feature_generation_uri]).run(params)
           lazar.parameters << {RDF::DC.title => "feature_dataset_uri", RDF::OT.paramValue => feature_dataset_uri}
           lazar[RDF::OT.featureDataset] = feature_dataset_uri
         end
@@ -91,7 +91,7 @@ module OpenTox
       end
 
       def predict(params)
-        @prediction_dataset = OpenTox::Dataset.new(nil, @subjectid) 
+        @prediction_dataset = OpenTox::Dataset.new
         # set instance variables and prediction dataset parameters from parameters
         params.each {|k,v|
           self.class.class_eval { attr_accessor k.to_sym }
@@ -104,9 +104,9 @@ module OpenTox
           instance_variable_set("@#{k}", [])
         }
 
-        @prediction_feature = OpenTox::Feature.new @prediction_feature_uri, @subjectid
-        @predicted_variable = OpenTox::Feature.new @predicted_variable_uri, @subjectid
-        @predicted_confidence = OpenTox::Feature.new @predicted_confidence_uri, @subjectid
+        @prediction_feature = OpenTox::Feature.new @prediction_feature_uri
+        @predicted_variable = OpenTox::Feature.new @predicted_variable_uri
+        @predicted_confidence = OpenTox::Feature.new @predicted_confidence_uri
         @prediction_dataset.metadata = {
           RDF::DC.title => "Lazar prediction for #{@prediction_feature.title}",
           RDF::DC.creator => @model_uri,
@@ -115,21 +115,21 @@ module OpenTox
           RDF::OT.predictedVariables => [@predicted_variable_uri,@predicted_confidence_uri]
         }
 
-        @training_dataset = OpenTox::Dataset.new(@training_dataset_uri,@subjectid)
+        @training_dataset = OpenTox::Dataset.new(@training_dataset_uri)
 
-        @feature_dataset = OpenTox::Dataset.new(@feature_dataset_uri, @subjectid)
+        @feature_dataset = OpenTox::Dataset.new(@feature_dataset_uri)
         bad_request_error "No features found in feature dataset #{@feature_dataset.uri}." if @feature_dataset.features.empty?
 
-        @similarity_feature = OpenTox::Feature.find_or_create({RDF::DC.title => "#{@similarity_algorithm.capitalize} similarity", RDF.type => [RDF::OT.Feature, RDF::OT.NumericFeature]}, @subjectid)
+        @similarity_feature = OpenTox::Feature.find_or_create({RDF::DC.title => "#{@similarity_algorithm.capitalize} similarity", RDF.type => [RDF::OT.Feature, RDF::OT.NumericFeature]})
         
         @prediction_dataset.features = [ @predicted_variable, @predicted_confidence, @prediction_feature, @similarity_feature ]
 
         prediction_feature_pos = @training_dataset.features.collect{|f| f.uri}.index @prediction_feature.uri
 
         if @dataset_uri
-          compounds = OpenTox::Dataset.new(@dataset_uri, @subjectid).compounds
+          compounds = OpenTox::Dataset.new(@dataset_uri).compounds
         else
-          compounds = [ OpenTox::Compound.new(@compound_uri, @subjectid) ]
+          compounds = [ OpenTox::Compound.new(@compound_uri) ]
         end
 
         @training_fingerprints = @feature_dataset.data_entries