opentox-ruby 0.0.1

data/lib/algorithm.rb

@@ -0,0 +1,82 @@
+
+module OpenTox
+  module Algorithm 
+    
+    
+    class Generic
+      
+      attr_accessor :uri, :title, :date
+      
+      def self.find(uri)
+        owl = OpenTox::Owl.from_uri(uri, "Algorithm")
+        return self.new(owl)
+      end
+      
+      protected
+      def initialize(owl)
+        @title = owl.get("title")
+        @date = owl.get("date")
+        @uri = owl.uri 
+      end
+      
+    end
+
+    class Fminer 
+
+      def self.create_feature_dataset(params)
+				LOGGER.debug File.basename(__FILE__) + ": creating feature dataset"
+        resource = RestClient::Resource.new(params[:feature_generation_uri], :user => @@users[:users].keys[0], :password => @@users[:users].values[0])
+        resource.post :dataset_uri => params[:dataset_uri], :feature_uri => params[:feature_uri]
+      end
+
+			def self.uri
+				File.join(@@config[:services]["opentox-algorithm"], "fminer")
+			end
+    end
+
+    class Lazar 
+			
+			def self.create_model(params)
+				LOGGER.debug params
+				LOGGER.debug File.basename(__FILE__) + ": creating model"
+				LOGGER.debug File.join(@@config[:services]["opentox-algorithm"], "lazar")
+        resource = RestClient::Resource.new(File.join(@@config[:services]["opentox-algorithm"], "lazar"), :user => @@users[:users].keys[0], :password => @@users[:users].values[0], :content_type => "application/x-yaml")
+        @uri = resource.post(:dataset_uri => params[:dataset_uri], :prediction_feature => params[:prediction_feature], :feature_generation_uri => File.join(@@config[:services]["opentox-algorithm"], "fminer")).body.chomp
+			end
+
+			def self.uri
+				File.join(@@config[:services]["opentox-algorithm"], "lazar")
+			end
+
+    end
+
+    class Similarity
+      def self.weighted_tanimoto(fp_a,fp_b,p)
+        common_features = fp_a & fp_b
+        all_features = (fp_a + fp_b).uniq
+        common_p_sum = 0.0
+        if common_features.size > 0
+          common_features.each{|f| common_p_sum += OpenTox::Utils.gauss(p[f])}
+          all_p_sum = 0.0
+          all_features.each{|f| all_p_sum += OpenTox::Utils.gauss(p[f])}
+          common_p_sum/all_p_sum
+        else
+          0.0
+        end
+      end
+      def self.euclidean(prop_a,prop_b)
+        common_properties = prop_a.keys & prop_b.keys
+        if common_properties.size > 1
+          dist_sum = 0
+          common_properties.each do |p|
+            dist_sum += (prop_a[p] - prop_b[p])**2
+          end
+          1/(1+Math.sqrt(dist_sum))
+        else
+          nil
+        end
+      end
+    end
+
+  end
+end

data/lib/compound.rb

@@ -0,0 +1,128 @@
+@@cactus_uri="http://cactus.nci.nih.gov/chemical/structure/"
+@@ambit_uri="http://ambit.uni-plovdiv.bg:8080/ambit2/depict/cdk?search="
+
+module OpenTox
+
+	class Compound #< OpenTox
+
+		attr_reader :inchi, :uri
+
+		# Initialize with <tt>:uri => uri</tt>, <tt>:smiles => smiles</tt> or <tt>:name => name</tt> (name can be also an InChI/InChiKey, CAS number, etc)
+		def initialize(params)
+			if params[:smiles]
+				@inchi = smiles2inchi(params[:smiles])
+				@uri = File.join(@@config[:services]["opentox-compound"],URI.escape(@inchi))
+			elsif params[:inchi]
+				@inchi = params[:inchi]
+				@uri = File.join(@@config[:services]["opentox-compound"],URI.escape(@inchi))
+			elsif params[:sdf]
+				@inchi = sdf2inchi(params[:sdf])
+				@uri = File.join(@@config[:services]["opentox-compound"],URI.escape(@inchi))
+			elsif params[:name]
+				# paranoid URI encoding to keep SMILES charges and brackets
+				@inchi = RestClient.get("#{@@cactus_uri}#{URI.encode(params[:name], Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))}/stdinchi").body.chomp
+				# this was too hard for me to debug and leads to additional errors (ch)
+				#@inchi = RestClientWrapper.get("#{@@cactus_uri}#{URI.encode(params[:name], Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))}/stdinchi").chomp
+				@uri = File.join(@@config[:services]["opentox-compound"],URI.escape(@inchi))
+			elsif params[:uri]
+				@uri = params[:uri]
+				case params[:uri]
+				when /ambit/ # Ambit does not deliver InChIs reliably
+					smiles = RestClientWrapper.get @uri, :accept => 'chemical/x-daylight-smiles'
+					@inchi = obconversion(smiles,'smi','inchi')
+				when /InChI/ # shortcut for IST services
+					@inchi = params[:uri].sub(/^.*InChI/, 'InChI')
+				else
+					@inchi = RestClientWrapper.get @uri, :accept => 'chemical/x-inchi'
+				end
+			end
+		end
+
+		# Get the (canonical) smiles
+		def smiles
+			obconversion(@inchi,'inchi','can')
+		end
+
+		def sdf
+			obconversion(@inchi,'inchi','sdf')
+		end
+
+		def gif
+			RestClientWrapper.get("#{@@cactus_uri}#{@inchi}/image")
+		end
+
+		def png
+      RestClientWrapper.get(File.join @uri, "image")
+		end
+
+		def names
+      begin
+        RestClientWrapper.get("#{@@cactus_uri}#{@inchi}/names")
+      rescue
+        "not available"
+      end
+		end
+
+    def display_smarts_uri(activating, deactivating, highlight = nil)
+      LOGGER.debug activating.to_yaml unless activating.nil?
+      activating_smarts = URI.encode "\"#{activating.join("\"/\"")}\""
+      deactivating_smarts = URI.encode "\"#{deactivating.join("\"/\"")}\""
+      if highlight.nil?
+        File.join @@config[:services]["opentox-compound"], "smiles", URI.encode(smiles), "smarts/activating", URI.encode(activating_smarts),"deactivating", URI.encode(deactivating_smarts)
+      else
+        File.join @@config[:services]["opentox-compound"], "smiles", URI.encode(smiles), "smarts/activating", URI.encode(activating_smarts),"deactivating", URI.encode(deactivating_smarts), "highlight", URI.encode(highlight)
+      end
+    end
+
+		def image_uri
+      File.join @uri, "image"
+		end
+
+		# Matchs a smarts string
+		def match?(smarts)
+			obconversion = OpenBabel::OBConversion.new
+			obmol = OpenBabel::OBMol.new
+			obconversion.set_in_format('inchi')
+			obconversion.read_string(obmol,@inchi) 
+			smarts_pattern = OpenBabel::OBSmartsPattern.new
+			smarts_pattern.init(smarts)
+			smarts_pattern.match(obmol)
+		end
+
+		# Match an array of smarts features, returns matching features
+		def match(smarts_array)
+			smarts_array.collect{|s| s if match?(s)}.compact
+		end
+
+		# AM
+		# Match an array of smarts features, returns (0)1 for (non)matching features at each pos
+		def match_all(smarts_array)
+			smarts_array.collect{|s| match?(s) ? 1 : 0 }
+		end
+
+		def sdf2inchi(sdf)
+			obconversion(sdf,'sdf','inchi')
+		end
+
+		def smiles2inchi(smiles)
+			obconversion(smiles,'smi','inchi')
+		end
+
+		def smiles2cansmi(smiles)
+			obconversion(smiles,'smi','can')
+		end
+
+		def obconversion(identifier,input_format,output_format)
+			obconversion = OpenBabel::OBConversion.new
+			obmol = OpenBabel::OBMol.new
+			obconversion.set_in_and_out_formats input_format, output_format
+			obconversion.read_string obmol, identifier
+			case output_format
+			when /smi|can|inchi/
+				obconversion.write_string(obmol).gsub(/\s/,'').chomp
+			else
+				obconversion.write_string(obmol)
+			end
+		end
+	end
+end

data/lib/config/config_ru.rb

@@ -0,0 +1,51 @@
+require 'rubygems'
+require 'rack'
+require 'rack/contrib'
+require 'application.rb'
+
+# log at centralized place
+logfile = "#{LOG_DIR}/#{ENV["RACK_ENV"]}.log"
+log = File.new(logfile, "a+")
+$stdout.reopen(log)
+$stderr.reopen(log)
+$stdout.sync = true
+$stderr.sync = true
+set :logging, false
+set :raise_errors, true 
+
+['public','tmp'].each do |dir|
+	FileUtils.mkdir_p dir unless File.exists?(dir)
+end
+ 
+use Rack::ShowExceptions
+if defined?(MAIL)
+
+	# monkeypatch with the original method
+	# strangely enough my mailserver returns "Connection refused - connect(2)" errors without this patch
+  module Rack
+    class MailExceptions
+
+      def send_notification(exception, env)
+        mail = generate_mail(exception, env)
+        smtp = config[:smtp]
+        env['mail.sent'] = true
+        return if smtp[:server] == 'example.com'
+
+        Net::SMTP.start smtp[:server], smtp[:port], smtp[:domain], smtp[:user_name], smtp[:password], smtp[:authentication] do |server|
+          mail.to.each do |recipient|
+            server.send_message mail.to_s, mail.from, recipient
+          end
+        end
+      end
+    end
+	end
+
+
+	require "socket"
+	use Rack::MailExceptions do |mail|
+			mail.to MAIL[:user_name]
+			mail.subject '[ERROR] %s'
+			mail.from "#{Socket.gethostname}@#{MAIL[:domain]}"
+			mail.smtp MAIL
+	end 
+end

data/lib/dataset.rb

@@ -0,0 +1,226 @@
+module OpenTox
+  
+  class Dataset 
+
+    attr_accessor :uri, :title, :creator, :data, :features, :compounds
+
+    def initialize( owl=nil )
+      @data = {}
+      @features = []
+      @compounds = []
+      
+      # creates dataset object from Opentox::Owl object
+      # use Dataset.find( <uri> ) to load dataset from rdf-supporting datasetservice
+      # note: does not load all feature values, as this is time consuming
+      if owl
+        raise "invalid param" unless owl.is_a?(OpenTox::Owl)
+        @title = owl.get("title")
+        @creator = owl.get("creator")
+        @uri = owl.uri
+        # when loading a dataset from owl, only compound- and feature-uris are loaded 
+        owl.load_dataset(@compounds, @features)
+        # all features are marked as dirty
+        # as soon as a feature-value is requested all values for this feature are loaded from the rdf
+        @dirty_features = @features.dclone
+        @owl = owl
+      end
+    end
+  
+    def self.find(uri, accept_header=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
+      
+      case accept_header
+      when "application/x-yaml"
+        d = YAML.load RestClientWrapper.get(uri.to_s.strip, :accept => 'application/x-yaml').to_s 
+        d.uri = uri unless d.uri
+      when "application/rdf+xml"
+        owl = OpenTox::Owl.from_uri(uri.to_s.strip, "Dataset")
+        d = Dataset.new(owl)
+      else
+        raise "cannot get datset with accept header: "+accept_header.to_s
+      end
+      d
+    end
+    
+    # converts a dataset represented in owl to yaml
+    # (uses a temporary dataset)
+    # note: to_yaml is overwritten, loads complete owl dataset values 
+    def self.owl_to_yaml( owl_data, uri)
+      owl = OpenTox::Owl.from_data(owl_data, uri, "Dataset")
+      d = Dataset.new(owl)
+      d.to_yaml
+    end
+    
+    # creates a new dataset, using only those compounsd specified in new_compounds
+    # returns uri of new dataset
+    def create_new_dataset( new_compounds, new_features, new_title, new_creator )
+      
+      LOGGER.debug "create new dataset with "+new_compounds.size.to_s+"/"+compounds.size.to_s+" compounds"
+      raise "no new compounds selected" unless new_compounds and new_compounds.size>0
+      
+      # load require features 
+      if ((defined? @dirty_features) && (@dirty_features & new_features).size > 0)
+        (@dirty_features & new_features).each{|f| load_feature_values(f)}
+      end
+      
+      dataset = OpenTox::Dataset.new
+      dataset.title = new_title
+      dataset.creator = new_creator
+      dataset.features = new_features
+      dataset.compounds = new_compounds
+      
+      # Copy dataset data for compounds and features
+      # PENDING: why storing feature values in an array? 
+      new_compounds.each do |c|
+        data_c = []
+        raise "no data for compound '"+c.to_s+"'" if @data[c]==nil
+        @data[c].each do |d|
+          m = {}
+          new_features.each do |f|
+            m[f] = d[f]
+          end
+          data_c << m 
+        end
+        dataset.data[c] = data_c
+      end
+      return dataset.save
+    end
+    
+    # returns classification value
+    def get_predicted_class(compound, feature)
+      v = get_value(compound, feature)
+      if v.is_a?(Hash)
+        k = v.keys.grep(/classification/).first
+        unless k.empty?
+        #if v.has_key?(:classification)
+          return v[k]
+        else
+          return "no classification key"
+        end
+      elsif v.is_a?(Array)
+        raise "predicted class value is an array\n"+
+          "value "+v.to_s+"\n"+
+          "value-class "+v.class.to_s+"\n"+
+          "dataset "+@uri.to_s+"\n"+
+          "compound "+compound.to_s+"\n"+
+          "feature "+feature.to_s+"\n"
+      else
+        return v
+      end
+    end
+    
+    # returns regression value
+    def get_predicted_regression(compound, feature)
+      v = get_value(compound, feature)
+      if v.is_a?(Hash)
+        k = v.keys.grep(/regression/).first
+        unless k.empty?
+          return v[k]
+        else
+          return "no regression key"
+        end
+      elsif v.is_a?(Array)
+        raise "predicted regression value is an array\n"+
+          "value "+v.to_s+"\n"+
+          "value-class "+v.class.to_s+"\n"+
+          "dataset "+@uri.to_s+"\n"+
+          "compound "+compound.to_s+"\n"+
+          "feature "+feature.to_s+"\n"
+      else
+        return v
+      end
+    end
+    
+    # returns prediction confidence if available
+    def get_prediction_confidence(compound, feature)
+      v = get_value(compound, feature)
+      if v.is_a?(Hash)
+        k = v.keys.grep(/confidence/).first
+        unless k.empty?
+        #if v.has_key?(:confidence)
+          return v[k].abs
+          #return v["http://ot-dev.in-silico.ch/model/lazar#confidence"].abs
+        else
+          # PENDING: return nil isntead of raising an exception
+          raise "no confidence key"
+        end
+      else
+        LOGGER.warn "no confidence for compound: "+compound.to_s+", feature: "+feature.to_s
+        return 1
+      end
+    end
+    
+    # return compound-feature value
+    def get_value(compound, feature)
+      if (defined? @dirty_features) && @dirty_features.include?(feature)
+        load_feature_values(feature)
+      end
+      
+      v = @data[compound]
+      return nil if v == nil # missing values for all features
+      if v.is_a?(Array)
+        # PENDING: why using an array here?
+        v.each do |e|
+          if e.is_a?(Hash)
+            if e.has_key?(feature)
+              return e[feature]
+            end
+          else
+            raise "invalid internal value type"
+          end
+        end
+        return nil #missing value
+      else
+        raise "value is not an array\n"+
+              "value "+v.to_s+"\n"+
+              "value-class "+v.class.to_s+"\n"+
+              "dataset "+@uri.to_s+"\n"+
+              "compound "+compound.to_s+"\n"+
+              "feature "+feature.to_s+"\n"
+      end
+    end
+
+    # loads specified feature and removes dirty-flag, loads all features if feature is nil
+    def load_feature_values(feature=nil)
+      if feature
+        raise "feature already loaded" unless @dirty_features.include?(feature)
+        @owl.load_dataset_feature_values(@compounds, @data, [feature])
+        @dirty_features.delete(feature)
+      else
+        @data = {} unless @data
+        @owl.load_dataset_feature_values(@compounds, @data, @dirty_features)
+        @dirty_features.clear
+      end
+    end
+    
+    # overwrite to yaml:
+    # in case dataset is loaded from owl:
+    # * load all values 
+    def to_yaml
+      # loads all features  
+      if ((defined? @dirty_features) && @dirty_features.size > 0)
+        load_feature_values
+      end
+      super
+    end
+    
+    # * remove @owl from yaml, not necessary
+    def to_yaml_properties
+      super - ["@owl"]
+    end
+
+    # saves (changes) as new dataset in dataset service
+    # returns uri
+    # uses to yaml method (which is overwritten)
+    def save
+      OpenTox::RestClientWrapper.post(@@config[:services]["opentox-dataset"],{:content_type =>  "application/x-yaml"},self.to_yaml).strip   
+    end
+  end
+end