lazar-gui 1.0.2 → 1.1.3

data/VERSION

@@ -1 +1 @@
-1.0.2
+1.1.3

data/application.rb

@@ -1,14 +1,16 @@
 #require_relative 'helper.rb'
-#require 'rdiscount'
+require 'rdiscount'
 include OpenTox
-#require File.join(ENV["HOME"],".opentox","config","lazar-gui.rb") # until added to ot-tools
 
-# DG: workaround for https://github.com/sinatra/sinatra/issues/808
-# Date: 18/11/2013
-#set :protection, :except => :path_traversal
+
+configure :production do
+  $logger = Logger.new(STDOUT)
+  enable :reloader
+end
 
 configure :development do
   $logger = Logger.new(STDOUT)
+  enable :reloader
 end
 
 helpers do
@@ -20,230 +22,91 @@ helpers do
 
 end
 
+before do
+  @version = File.read("VERSION").chomp
+end
+
+not_found do
+  redirect to('/predict')
+end
+
 get '/?' do
   redirect to('/predict') 
 end
 
 get '/predict/?' do
-  @version = File.read("VERSION").chomp
-  @models = OpenTox::Model::Prediction.all
+  @models = OpenTox::Model::Validation.all
+  @models = @models.delete_if{|m| m.model.name =~ /\b(Net cell association)\b/}
   @endpoints = @models.collect{|m| m.endpoint}.sort.uniq
   @models.count <= 0 ? (haml :info) : (haml :predict)
 end
 
 get '/predict/modeldetails/:model' do
-  model = OpenTox::Model::Prediction.find params[:model]
-  crossvalidations = model.crossvalidations
-  #confidence_plots = crossvalidations.collect{|cv| [cv.id, cv.confidence_plot]}
-  #confidence_plots.each do |confp|
-  #  File.open(File.join('public', "confp#{confp[0]}.svg"), 'w'){|file| file.write(confp[1])} unless File.exists? File.join('public', "confp#{confp[0]}.svg")
-  #end
-  #if model.regression?
-  #  correlation_plots = crossvalidations.collect{|cv| [cv.id, cv.correlation_plot]}
-  #  correlation_plots.each do |corrp|
-  #    File.open(File.join('public', "corrp#{corrp[0]}.svg"), 'w'){|file| file.write(corrp[1])} unless File.exists? File.join('public', "corrp#{corrp[0]}.svg")
-  #  end
-  #end
-
-  return haml :model_details, :layout=> false, :locals => {:model => model}
-end
+  model = OpenTox::Model::Validation.find params[:model]
+  crossvalidations = OpenTox::Validation::RepeatedCrossValidation.find(model.repeated_crossvalidation_id).crossvalidations
 
-get '/jme_help/?' do
-  File.read(File.join('views','jme_help.html'))
+  return haml :model_details, :layout=> false, :locals => {:model => model, :crossvalidations => crossvalidations}
 end
 
 # get individual compound details
 get '/prediction/:neighbor/details/?' do
-  @compound = OpenTox::Compound.new params[:neighbor]
+  @compound = OpenTox::Compound.find params[:neighbor]
   @smiles = @compound.smiles
-  task = OpenTox::Task.run("Get names for '#{@smiles}'.") do
-    names = @compound.names
-  end
-  task.wait
-  
-  case task[RDF::OT.hasStatus]
-  when "Error"
-    @names = "No names for this compound available."
-  when "Completed"
-    @names = @compound.names
-  else
+  begin
+    @names = @compound.names.nil? ? "No names for this compound available." : @compound.names
+  rescue
     @names = "No names for this compound available."
   end
   @inchi = @compound.inchi.gsub("InChI=", "")
 
   haml :details, :layout => false
 end
-=begin
-# sdf representation for datasets
-#TODO fix 502 errors from compound service
-get '/predict/:dataset_uri/sdf/?' do
-  uri = CGI.unescape(params[:dataset_uri])
-  $logger.debug uri
-  bad_request_error "Not a dataset uri." unless URI.dataset? uri
-  dataset = OpenTox::Dataset.find uri
-  @compounds = dataset.compounds
-  @data_entries = dataset.data_entries
-  sum=""
-  @compounds.each_with_index{ |c, idx|
-    sum << c.inchi
-    sum << c.sdf.sub(/\n\$\$\$\$/,'')
-    @data_entries[idx].each{ |f,v|
-      sum << "> <\"#{f}\">\n"
-      sum << v.join(", ")
-      sum << "\n\n"
-    }
-    sum << "$$$$\n"
-  }
-  send_file sum, :filename => "#{dataset.title}.sdf"
-end
-=end
-# fingerprints for compound in predictions
-get '/prediction/:model_uri/:type/:compound_uri/fingerprints/?' do
-  @type = params[:type]
-  model = OpenTox::Model::Lazar.find params[:model_uri]
-  feature_dataset = OpenTox::Dataset.find model[RDF::OT.featureDataset]
-  @compound = OpenTox::Compound.new params[:compound_uri]
-  @significant_fragments = []
-  if @type =~ /classification/i
-    # collect all feature values with fingerprint
-    fingerprints = OpenTox::Algorithm::Descriptor.send("smarts_match", [@compound], feature_dataset.features.collect{ |f| f[RDF::DC.title]})[@compound.uri]
-    #$logger.debug "fingerprints:\t#{fingerprints}\n"
-
-    # collect fingerprints with value 1
-    @fingerprint_values = fingerprints.collect{|smarts, value| [smarts, value] if value > 0}
-    
-    # collect all features from feature_dataset
-    @features = feature_dataset.features.collect{|f| f }
-    
-    # search for each fingerprint in all features and collect feature values( effect, smarts, pValue )
-    @fingerprint_values.each{ |fi, v| @features.each{ |f| @significant_fragments << [f[RDF::OT.effect].to_i, f[RDF::OT.smarts], f[RDF::OT.pValue]] if fi == f[RDF::OT.smarts] } }
-    
-    # pass value_map, important to interprete effect value
-    prediction_feature_uri = ""
-    model.parameters.each {|p|
-      if p[RDF::DC.title].to_s == "prediction_feature_uri"
-        prediction_feature_uri = p[RDF::OT.paramValue].object
-      end
-    }
-    prediction_feature = OpenTox::Feature.find prediction_feature_uri
-    @value_map = prediction_feature.value_map
-
-  else #regression
-    feature_calc_algo = ""
-    model.parameters.each {|p|
-      if p[RDF::DC.title].to_s == "feature_calculation_algorithm"
-        feature_calc_algo = p[RDF::OT.paramValue].object
-      end
-    }
 
-    @desc = []
-    fingerprints = OpenTox::Algorithm::Descriptor.send( feature_calc_algo, [ @compound ], feature_dataset.features.collect{ |f| f[RDF::DC.title] } )
-    fingerprints.each{|x, h| h.each{|descriptor, value| @desc << [descriptor, [value]]}}
-    
-    pc_descriptor_titles_descriptions = {}
-    feature_dataset.features.collect{ |f|
-      pc_descriptor_titles_descriptions[f[RDF::DC.title]]= f[RDF::DC.description]
-    }
-
-    @desc.each{|d, v| @significant_fragments << [pc_descriptor_titles_descriptions[d], v] }
-  end
-
-  haml :significant_fragments, :layout => false
+get '/jme_help/?' do
+  File.read(File.join('views','jme_help.html'))
 end
 
-get '/prediction/:model_uri/:type/:neighbor/significant_fragments/?' do
-  @type = params[:type]
-  @compound = OpenTox::Compound.new params[:neighbor]
-  model = OpenTox::Model::Lazar.find params[:model_uri]
-  #$logger.debug "model for significant fragments:\t#{model.uri}"
-  
-  feature_dataset = OpenTox::Dataset.find model[RDF::OT.featureDataset]
-  $logger.debug "feature_dataset_uri:\t#{feature_dataset.uri}\n"
-  
-  # load all compounds
-  feature_dataset.compounds
-  
-  # load all features
-  @features = feature_dataset.features.collect{|f| f}
-  
-  # find all features and values for a neighbor compound
-  @significant_fragments = []
-  # check type first
-  if @type =~ /classification/i
-    # get compound index in feature dataset
-    c_idx = feature_dataset.compound_indices @compound.uri
-
-    # collect feature uris with value
-    @feat = @features.collect{|f| [feature_dataset.data_entry_value(c_idx[0], f.uri), f.uri]}
-    #$logger.debug "@feat:\t#{@feat}\n"
-
-    # pass feature uris if value > 0
-    @feat.each do |f|
-      # search relevant features
-      if f[0] > 0
-        f = OpenTox::Feature.find f[1]
-        # pass relevant features with [ effect, smarts, pValue ] 
-        @significant_fragments << [f[RDF::OT.effect].to_i, f[RDF::OT.smarts], f[RDF::OT.pValue].to_f.round(3)]
-      end
-    end
-    # pass value_map, important to interprete effect value
-    prediction_feature_uri = ""
-    model.parameters.each {|p|
-      if p[RDF::DC.title].to_s == "prediction_feature_uri"
-        prediction_feature_uri = p[RDF::OT.paramValue].object
-      end
-    }
-    prediction_feature = OpenTox::Feature.find prediction_feature_uri
-    @value_map = prediction_feature.value_map
-
-  else # regression
-    # find a value in feature dataset by compound and feature
-    @values = @features.collect{|f| feature_dataset.values(@compound, f)}
-    #$logger.debug "values in fd:\t#{@values}"
-    
-    @features.each_with_index{|f, i| @significant_fragments << [f.description, @values[i]]}
-  end  
-  #$logger.debug "significant fragments:\t#{@significant_fragments}\n"
-  
-  haml :significant_fragments, :layout => false
+get '/predict/dataset/:name' do
+  response['Content-Type'] = "text/csv"
+  dataset = Dataset.find_by(:name=>params[:name])
+  csv = dataset.to_csv
+  csv
 end
 
 get '/predict/?:csv?' do
   response['Content-Type'] = "text/csv"
-  @csv = "\"Compound\",\"Endpoint\",\"Type\",\"Prediction\",\"Confidence\"\n"
+  @csv = "\"Compound\",\"Endpoint\",\"Type\",\"Prediction\",\"95% Prediction interval\"\n"
   @@batch.each do |key, values|
+    compound = key
+    smiles = compound.smiles
     values.each do |array|
       model = array[0]
+      type = model.model.class.to_s.match("Classification") ? "Classification" : "Regression"
       prediction = array[1]
-      compound = key.smiles
-      mw = key.molecular_weight
       endpoint = "#{model.endpoint.gsub('_', ' ')} (#{model.species})"
       if prediction[:confidence] == "measured"
         if prediction[:value].is_a?(Array)
           prediction[:value].each do |value|
-            type = ""
-            weight = Compound.from_smiles(compound).mmol_to_mg(value, mw)
-            pred = value.numeric? ? "#{'%.2e' % value} (#{model.unit}) | #{'%.2e' % weight} (mg/kg_bw/day)" : value
-            confidence = "measured activity"
-            @csv += "\"#{compound}\",\"#{endpoint}\",\"#{type}\",\"#{pred}\",\"#{confidence}\"\n"
+            pred = value.numeric? ? "#{value} (#{model.unit}), #{compound.mmol_to_mg(value.delog10)} #{(model.unit =~ /\b(mol\/L)\b/) ? "(mg/L)" : "(mg/kg_bw/day)"}" : value
+            int = (prediction[:prediction_interval].nil? ? nil : prediction[:prediction_interval])
+            interval = (int.nil? ? "--" : "#{int[1].delog10} - #{int[0].delog10} (#{model.unit})")
+            @csv += "\"#{smiles}\",\"#{endpoint}\",\"#{type}\",\"#{pred}\",\"#{interval}\"\n"
           end
         else
-          type = ""
-          weight = Compound.from_smiles(compound).mmol_to_mg(prediction[:value], mw)
-          pred = prediction[:value].numeric? ? "#{'%.2e' % prediction[:value]} (#{model.unit}) | #{'%.2e' % weight} (mg/kg_bw/day)" : prediction[:value]
+          pred = prediction[:value].numeric? ? "#{prediction[:value]} (#{model.unit}), #{compound.mmol_to_mg(prediction[:value].delog10)} #{(model.unit =~ /\b(mol\/L)\b/) ? "(mg/L)" : "(mg/kg_bw/day)"}" : prediction[:value]
           confidence = "measured activity"
         end
       elsif prediction[:neighbors].size > 0
-        weight = Compound.from_smiles(compound).mmol_to_mg(prediction[:value], mw)
         type = model.model.class.to_s.match("Classification") ? "Classification" : "Regression"
-        pred = prediction[:value].numeric? ? "#{'%.2e' % prediction[:value]} (#{model.unit}) | #{'%.2e' % weight} (mg/kg_bw/day)" : prediction[:value]
-        confidence = prediction[:confidence]
+        pred = prediction[:value].numeric? ? "#{prediction[:value].delog10} (#{model.unit}), #{compound.mmol_to_mg(prediction[:value].delog10)} #{(model.unit =~ /\b(mol\/L)\b/) ? "(mg/L)" : "(mg/kg_bw/day)"}" : prediction[:value]
+        int = (prediction[:prediction_interval].nil? ? nil : prediction[:prediction_interval])
+        interval = (int.nil? ? "--" : "#{int[1].delog10} - #{int[0].delog10} (#{model.unit})")
       else
         type = ""
         pred = "Not enough similar compounds in training dataset."
-        confidence = ""
+        interval = ""
       end
-      @csv += "\"#{compound}\",\"#{endpoint}\",\"#{type}\",\"#{pred}\",\"#{confidence}\"\n" unless prediction[:value].is_a?(Array)
+      @csv += "\"#{smiles}\",\"#{endpoint}\",\"#{type}\",\"#{pred}\",\"#{interval}\"\n" unless prediction[:value].is_a?(Array)
     end
   end
   @csv
@@ -261,11 +124,21 @@ post '/predict/?' do
       f.write(params[:fileselect][:tempfile].read)
     end
     @filename = params[:fileselect][:filename]
-    input = OpenTox::Dataset.from_csv_file File.join "tmp", params[:fileselect][:filename]
-    dataset = OpenTox::Dataset.find input.id 
+    begin
+      input = OpenTox::Dataset.from_csv_file File.join("tmp", params[:fileselect][:filename]), true
+      if input.class == OpenTox::Dataset
+        dataset = OpenTox::Dataset.find input
+      else
+        @error_report = "Could not serialize file '#{@filename}' ."
+        return haml :error
+      end
+    rescue
+      @error_report = "Could not serialize file '#{@filename}' ."
+      return haml :error
+    end
     @compounds = dataset.compounds
     if @compounds.size == 0
-      @error_report = "No valid SMILES submitted."
+      @error_report = dataset[:warnings]
       dataset.delete
       return haml :error
     end
@@ -273,13 +146,15 @@ post '/predict/?' do
     @compounds.each do |compound|
       @batch[compound] = []
       params[:selection].keys.each do |model_id|
-        model = Model::Prediction.find model_id
+        model = OpenTox::Model::Validation.find model_id
         prediction = model.predict(compound)
         @batch[compound] << [model, prediction]
       end
     end
     @@batch = @batch
+    @warnings = dataset[:warnings]
     dataset.delete
+    File.delete File.join("tmp", params[:fileselect][:filename])
     return haml :batch
   end
 
@@ -291,26 +166,31 @@ post '/predict/?' do
     # get compound from SMILES
     @compound = Compound.from_smiles @identifier
     if @compound.blank?
-      @error_report = "Attention, '#{@identifier}' is not a valid SMILES string."
+      @error_report = "'#{@identifier}' is not a valid SMILES string."
       return haml :error
     end
 
     @models = []
     @predictions = []
     params[:selection].keys.each do |model_id|
-      model = Model::Prediction.find model_id
+      model = OpenTox::Model::Validation.find model_id
       @models << model
       @predictions << model.predict(@compound)
     end
     haml :prediction
   end
 end
-=begin
+
+get '/license' do
+  @license = RDiscount.new(File.read("LICENSE.md")).to_html
+  haml :license, :layout => false
+end
+
 get '/faq' do
   @faq = RDiscount.new(File.read("FAQ.md")).to_html
-  haml :faq, :layout => :faq_layout
+  haml :faq, :layout => false
 end
-=end
+
 get '/style.css' do
   headers 'Content-Type' => 'text/css; charset=utf-8'
   scss :style

data/config.ru

@@ -1,5 +1,6 @@
-SERVICE = "lazar"
+ENV["LAZAR_ENV"] = "production"
 require 'bundler'
 Bundler.require
 require File.expand_path './application.rb'
+require "sinatra/reloader" if development?
 run Sinatra::Application

data/helper.rb

@@ -1,218 +1,3 @@
 helpers do
-
-  def is_authorized(uri, action)
-    if OpenTox::Authorization.server && session[:subjectid] != nil
-      return OpenTox::Authorization.authorized?(uri, action, session[:subjectid])
-    else
-      return true
-    end
-    return false
-  end
-
-  def is_aluist
-    OpenTox::Authorization.list_user_groups(session[:username], session[:subjectid]).include?("aluist")
-  end
-
-  def hide_link(destination)
-    @link_id = 0 unless @link_id
-    @link_id += 1
-    haml :js_link, :locals => {:name => "hide", :destination => destination, :method => "hide"}, :layout => false
-  end
-
-  def toggle_link(destination,name)
-    @link_id = 0 unless @link_id
-    @link_id += 1
-    haml :js_link, :locals => {:name => name, :destination => destination, :method => "toggle"}, :layout => false
-  end
-
-  def sort(descriptors,value_map)
-    features = {:activating => [], :deactivating => [], :pc_features => []}
-    if descriptors.kind_of?(Array)
-      descriptors.each do |d|
-        if !value_map.empty?
-          features[:activating] << {:smarts => d[OT.smarts],:p_value => d[OT.pValue]} if d[OT.effect] == 2
-          features[:deactivating] << {:smarts => d[OT.smarts],:p_value => d[OT.pValue]} if d[OT.effect] == 1
-        else
-          if d[OT.effect] =~ TRUE_REGEXP 
-            features[:activating] << {:smarts => d[OT.smarts],:p_value => d[OT.pValue]} 
-          elsif d[OT.effect] =~ FALSE_REGEXP 
-            features[:deactivating] << {:smarts => d[OT.smarts],:p_value => d[OT.pValue]} 
-          end
-        end
-      end
-    else
-      descriptors.each do |d,v|
-        features[:pc_features] << {:feature => d, :value => v}
-      end
-    end
-    features
-  end
-
-  def compound_image(compound,descriptors,value_map)
-    haml :compound_image, :locals => {:compound => compound, :features => sort(descriptors,value_map)}, :layout => false
-  end
   
-  def activity_markup(activity,value_map)
-    if value_map and !value_map.empty?
-      if value_map.size == 2
-        activity = value_map.index(activity) if value_map.has_value? activity
-        if activity.to_i == 2
-          haml ".active #{value_map[activity]}", :layout => false
-        elsif activity.to_i == 1
-          haml ".inactive #{value_map[activity]}", :layout => false
-        else
-          haml ".other #{activity.to_s}", :layout => false
-        end
-      else
-        haml ".other #{activity.to_s}", :layout => false
-      end
-    elsif OpenTox::Algorithm::numeric? activity
-      haml ".other #{sprintf('%.03g', activity.to_f)}", :layout => false
-    else
-      haml ".other #{activity.to_s}", :layout => false
-    end
-=begin
-    case activity.class.to_s
-    when /Float/
-      haml ".other #{sprintf('%.03g', activity)}", :layout => false
-    when /String/
-      case activity
-      when "true"
-        haml ".active active", :layout => false
-      when "false"
-        haml ".inactive inactive", :layout => false
-      else
-        haml ".other #{activity.to_s}", :layout => false
-      end
-    else 
-      if activity #true
-        haml ".active active", :layout => false
-      elsif !activity # false
-        haml ".inactive inactive", :layout => false
-      else
-        haml ".other #{activity.to_s}", :layout => false
-      end
-    end
-=end
-  end
-
-  def neighbors_navigation
-    @page = 0 unless @page
-    haml :neighbors_navigation, :layout => false
-  end
-
-  def models_navigation
-    @page = 0 unless @page
-    haml :models_navigation, :layout => false
-  end
-
-  def models_navigation_bottom
-    @page = 0 unless @page
-    haml :models_navigation_bottom, :layout => false
-  end
-
-  def endpoint_option_list(max_time=3600)
-    out = ""
-    tmpfile = File.join(TMP_DIR, 'endpoint_option_list')
-    if File.exists? tmpfile
-      if Time.now-File.mtime(tmpfile) <= max_time
-        f = File.open(tmpfile, 'r+')
-        f.each{|line| out << line}
-        return out
-      else
-        File.unlink(tmpfile)
-      end
-    end
-    result = endpoint_selection()
-    if result.lines.count > 3
-      f = File.new(tmpfile,'w')
-      f.print result
-      f.close
-    end
-    result
-  end
-
-  def endpoint_level(endpoint="Endpoints", level=1)
-    results = OpenTox::Ontology::Echa.echa_endpoints(endpoint) rescue results = []
-    out = ""
-    out += "<ul id='list_#{endpoint}' class='endpoint level_#{level}'>\n" if results.size > 0
-    results.each do |result|
-      r = result.split(',')
-      endpointname = CGI.escape(r.first.split("#").last).gsub(".","")
-      title = r[1..r.size-1].to_s
-      out += "  <li class='level_#{level}'><input type='radio' name='endpoint' value='#{result}' id='#{endpointname}' class='endpoint_list' /><label for='#{endpointname}' id='label_#{endpointname}'>#{title.gsub("\"","")}</label>\n"
-      out += endpoint_level(endpointname, level + 1)
-      out += "</li>\n"
-    end
-    out += "</ul>\n" if results.size > 0
-    return out
-  end
-
-  def endpoint_selection()
-    out = "<span id='endpoint_label'></span><input type='button' id='endpoint_list_button' value='Select endpoint' /> \n
-    <div id='div_endpoint'>\n"
-    out += "<b>Please select:</b>\n"
-    out += endpoint_level
-    js = ""
-    out += "</div>\n"
-    return out
-  end
-
-  def logmmol_to_mg(value ,mw)
-    mg = round_to((10**(-1.0*round_to(value.to_f, 2))*(mw.to_f*1000)),4)
-    return mg
-  end
-
-  def logmg_to_mg(value)
-    mg = round_to(10**round_to(value.to_f, 2),4)
-    return mg
-  end
-
-  def ptd50_to_td50(value ,mw)
-    td50 = round_to((10**(-1.0*round_to(value.to_f, 2))*(mw.to_f*1000)),4)
-    return td50   
-  end
-
-  def round_to(value, deci)
-    rounded = (value.to_f*(10**deci)).round / (10**deci).to_f
-    return rounded
-  end
-
-  def calc_mw(compound_uri)
-    ds = OpenTox::Dataset.new()
-    ds.save(@subjectid)
-    ds.add_compound(compound_uri)
-    ds.save(@subjectid)
-    mw_algorithm_uri = File.join(CONFIG[:services]["opentox-algorithm"],"pc/MW")
-    mw_uri = OpenTox::RestClientWrapper.post(mw_algorithm_uri, {:dataset_uri=>ds.uri})
-    ds.delete(@subjectid)
-    mw_ds = OpenTox::Dataset.find(mw_uri, @subjectid)
-    mw = mw_ds.data_entries[compound_uri][mw_uri.to_s + "/feature/MW"].first.to_f
-    mw_ds.delete(@subjectid)
-    return mw 
-  end
-
-  def transform(value, compound_uri, name, haml)
-    prediction_trans = nil
-    model_name = name.to_s.downcase
-    if model_name.include? "ptd50"
-      mw = calc_mw(compound_uri)
-      td50 = ptd50_to_td50(value, mw)
-      prediction_trans = "TD50: #{td50}"
-    elsif model_name.include? "loael"
-      if model_name.include? "mol"
-        mw = calc_mw(compound_uri)
-        mg = logmmol_to_mg(value, mw)
-        prediction_trans = "mg/kg bw/day: #{mg}"
-      elsif model_name.include? "mg"
-        mg = logmg_to_mg(value)
-        prediction_trans = "mg/kg bw/day: #{mg}"
-      end
-    end
-    if haml == true
-      haml ".other #{prediction_trans.to_s}", :layout => false
-    else
-      return prediction_trans
-    end
-  end
 end