opentox-ruby-api-wrapper 1.1.0

data/README.rdoc

@@ -0,0 +1,23 @@
+= opentox-ruby-api-wrapper
+
+Ruby wrapper for the OpenTox REST API (http://www.opentox.org)
+
+== Installation
+
+Run the following if you haven't already:
+
+	gem sources -a http://gems.github.com
+
+Install the gem:
+
+	sudo gem install helma-opentox-ruby-api-wrapper 
+
+== Usage
+
+- set the environment variables OPENTOX_COMPOUNDS, OPENTOX_FEATURES, OPENTOX_DATASETS, OPENTOX_FMINER to the base URI of the OpenTox REST webservices
+- require 'opentox-ruby-api-wrapper' in your ruby application
+- consult the rdoc API documentation for details 
+
+== Copyright
+
+Copyright (c) 2009 Christoph Helma. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,64 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "opentox-ruby-api-wrapper"
+    gem.summary = %Q{Ruby wrapper for the OpenTox REST API}
+    gem.description = %Q{Ruby wrapper for the OpenTox REST API (http://www.opentox.org)}
+    gem.email = "helma@in-silico.ch"
+    gem.homepage = "http://github.com/helma/opentox-ruby-api-wrapper"
+    gem.authors = ["Christoph Helma"]
+		gem.add_dependency "technoweenie-rest-client"
+		gem.add_dependency "sinatra"
+		gem.add_dependency "rack"
+		gem.add_dependency "rack-contrib"
+		gem.add_dependency "thin"
+		gem.add_dependency "cucumber"
+		gem.add_dependency "ezmobius-redis-rb"
+		gem.files =  FileList["[A-Z]*", "{bin,generators,lib,test}/**/*", 'lib/jeweler/templates/.gitignore']
+		gem.files.include %w(lib/tasks/opentox.rb, lib/tasks/redis.rb, lib/environment.rb, lib/algorithm.rb, lib/compound.rb, lib/dataset.rb, lib/feature.rb, lib/model.rb, lib/utils.rb, lib/templates/*)
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "opentox-ruby-api-wrapper #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+1.1.0

data/lib/algorithm.rb

@@ -0,0 +1,37 @@
+module OpenTox
+	module Algorithm 
+
+		class Fminer < OpenTox
+			# Create a new dataset with BBRC features
+			def self.create(params)
+				puts  params[:dataset_uri]
+				uri = RestClient.post File.join(@@config[:services]["opentox-algorithm"],'fminer'), :dataset_uri => params[:dataset_uri]
+				print "fminer finsihed "
+				puts uri
+				uri
+			end
+		end
+
+		class Similarity < OpenTox
+
+			def self.tanimoto(dataset1,compound1,dataset2,compound2)
+				RestClient.get File.join(@@config[:services]["opentox-algorithm"], 'tanimoto/dataset',dataset1.name,compound1.inchi,'dataset',dataset2.name,compound2.inchi)
+			end
+
+			def self.weighted_tanimoto(dataset1,compound1,dataset2,compound2)
+				# URI.escape does not work here
+				uri = File.join(@@config[:services]["opentox-algorithm"], 'weighted_tanimoto/dataset',CGI.escape(dataset1.name),'compound',CGI.escape(compound1.inchi),'dataset',CGI.escape(dataset2.name),'compound',CGI.escape(compound2.inchi))
+				RestClient.get uri
+			end
+
+		end
+
+		class Lazar < OpenTox
+			# Create a new prediction model from a dataset
+			def self.create(params)
+				RestClient.post File.join(@@config[:services]["opentox-algorithm"],"lazar_classification"), params
+			end
+		end
+
+	end
+end

data/lib/compound.rb

@@ -0,0 +1,67 @@
+module OpenTox
+
+	# uri: /compound/:inchi
+	class Compound < OpenTox
+
+		attr_reader :inchi
+
+		# 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)
+			@@cactus_uri="http://cactus.nci.nih.gov/chemical/structure/"
+			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[:name]
+				@inchi = RestClient.get "#{@@cactus_uri}#{params[:name]}/stdinchi"
+				@uri = File.join(@@config[:services]["opentox-compound"],URI.escape(@inchi))
+			elsif params[:uri]
+				@inchi = params[:uri].sub(/^.*InChI/, 'InChI')
+				@uri = params[:uri]
+			end
+		end
+
+		# Get the (canonical) smiles
+		def smiles
+			obconversion(@inchi,'inchi','can')
+		end
+
+		def sdf
+			obconversion(@inchi,'inchi','sdf')
+		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_dataset)
+			smarts_dataset.all_features.collect{ |uri| uri if self.match?(Feature.new(:uri => uri).name) }.compact
+		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
+			obconversion.write_string(obmol).gsub(/\s/,'').chomp
+		end
+	end
+end

data/lib/dataset.rb

@@ -0,0 +1,94 @@
+module OpenTox
+
+	# key: /datasets
+	# set: dataset uris
+	# key: /dataset/:dataset/compounds
+	# set: compound uris
+	# key: /dataset/:dataset/compound/:inchi
+	# set: feature uris
+	class Dataset < OpenTox
+
+		# Initialize with <tt>:uri => uri</tt> or <tt>:name => name</tt> (creates a new dataset)
+		def initialize(uri)
+			super(uri)
+		end
+
+		def self.create(params)
+			uri = RestClient.post @@config[:services]["opentox-dataset"], :name => params[:name]
+			Dataset.new(uri.to_s)
+		end
+
+		def self.find(params)
+			begin
+				if params[:name]
+					uri = File.join(@@config[:services]["opentox-dataset"], URI.encode(params[:name]))
+				elsif params[:uri]
+					uri = params[:uri]
+				end
+				RestClient.get uri # check if the resource is available
+				Dataset.new(uri) if uri
+			rescue
+				nil
+			end
+		end
+
+		def self.find_or_create(params)
+			self.create(params) unless self.find(params)
+		end
+
+		def self.base_uri
+			@@config[:services]["opentox-dataset"]
+		end
+
+		def import(params)
+			if params[:csv]
+				# RestClient seems not to work for file uploads
+				#RestClient.post @uri + '/import', :compound_format => params[:compound_format], :content_type => "text/csv", :file => File.new(params[:csv])
+				`curl -X POST -F "file=@#{params[:csv]};type=text/csv" -F compound_format=#{params[:compound_format]} #{@uri + '/import'}`
+			end
+		end
+
+		def add(features)
+			RestClient.put @uri, :features => features
+		end
+
+		# Get all compounds from a dataset
+		def compound_uris
+			RestClient.get(File.join(@uri, 'compounds')).split("\n")
+		end
+
+		def compounds
+			compound_uris.collect{|uri| Compound.new(:uri => uri)}
+		end
+
+		# Get all features for a compound
+		def feature_uris(compound)
+			uri = File.join(@uri, 'compound', CGI.escape(compound.inchi)) # URI.encode does not work here
+			RestClient.get(uri).split("\n")
+		end
+
+		# Get all features for a compound
+		def features(compound)
+			feature_uris(compound).collect{|uri| Feature.new(:uri => uri)}
+		end
+
+		def all_features
+			RestClient.get(File.join(@uri, 'features')).split("\n")
+		end
+
+		# Delete a dataset
+		def delete
+			RestClient.delete @uri
+		end
+
+		def tanimoto(dataset)
+			RestClient.get(File.join(@uri,'tanimoto',dataset.path))
+		end
+
+		def weighted_tanimoto(dataset)
+			RestClient.get(File.join(@uri,'weighted_tanimoto',dataset.path))
+		end
+
+	end
+
+end

data/lib/environment.rb

@@ -0,0 +1,33 @@
+# set default environment
+ENV['RACK_ENV'] = 'test' unless ENV['RACK_ENV']
+
+# load configuration
+basedir = File.join(ENV['HOME'], ".opentox")
+config_dir = File.join(basedir, "config")
+@@tmp_dir = File.join(basedir, "tmp")
+config_file = File.join(config_dir, "#{ENV['RACK_ENV']}.yaml")
+
+if File.exist?(config_file)
+	@@config = YAML.load_file(config_file)
+else
+	FileUtils.mkdir_p config_dir
+	FileUtils.mkdir_p @@tmp_dir
+	FileUtils.cp(File.join(File.dirname(__FILE__), 'templates/config.yaml'), config_file)
+	puts "Please edit #{config_file} and restart your application."
+	exit
+end
+
+# configure redis database
+begin
+	case ENV['RACK_ENV']
+	when 'production'
+		@@redis = Redis.new :db => 0
+	when 'development'
+		@@redis = Redis.new :db => 1
+	when 'test'
+		@@redis = Redis.new :db => 2
+		@@redis.flush_db
+	end
+rescue
+	puts "Redis database not running, please start it with 'rake redis:start'."
+end

data/lib/feature.rb

@@ -0,0 +1,48 @@
+module OpenTox
+
+	# uri: /feature/:name/:property_name/:property_value/...
+	class Feature < OpenTox
+
+		attr_accessor :name, :values
+
+		def initialize(params)
+			if params[:uri]
+				@uri = params[:uri]
+				items = URI.split(@uri)[5].split(/\//)
+				@name = items[1]
+				@values = {}
+				i = 2
+				while i < items.size
+					@values[items[i]] = items[i+1]
+					i += 2
+				end
+			else 
+				@name = params[:name]
+				@values = {}
+				params.each do |k,v|
+					@values[k] = v unless k.to_s == 'name'
+				end
+				@uri = File.join(@@config[:services]["opentox-feature"],path)
+			end
+		end
+
+		def values_path
+			path = '' 
+			@values.each do |k,v|
+				path = File.join path, URI.encode(k.to_s), URI.encode(v.to_s)
+			end
+			path
+		end
+
+		def path
+			File.join(URI.encode(@name),values_path)
+		end
+
+		def value(property)
+			items = @uri.split(/\//)
+			i = items.index(property)
+			items[i+1]
+		end
+
+	end
+end

data/lib/helper.rb

@@ -0,0 +1,26 @@
+helpers do
+
+	# Authentification
+  def protected!
+    response['WWW-Authenticate'] = %(Basic realm="Testing HTTP Auth") and \
+    throw(:halt, [401, "Not authorized\n"]) and \
+    return unless authorized?
+  end
+
+  def authorized?
+    @auth ||=  Rack::Auth::Basic::Request.new(request.env)
+    @auth.provided? && @auth.basic? && @auth.credentials && @auth.credentials == ['api', API_KEY]
+  end
+
+	    
+=begin
+	def xml(object)
+		builder do |xml| 
+			xml.instruct!
+			object.to_xml
+		end
+	end
+=end
+
+end
+

data/lib/model.rb

@@ -0,0 +1,71 @@
+module OpenTox
+
+	module Model 
+
+		class LazarClassification < OpenTox
+
+			# Create a new prediction model from a dataset
+			def initialize(uri)
+				super(uri)
+			end
+
+			def self.create(params)
+				uri = RestClient.post File.join(@@config[:services]["opentox-model"], 'lazar_classification'), params
+				puts "URI: " + uri
+				LazarClassification.new(uri.to_s)
+			end
+
+			def self.find(name)
+				uri = RestClient.get File.join(@@config[:services]["opentox-model"], 'lazar_classification', URI.encode(params[:name]))
+				LazarClassification.new(uri)
+			end
+
+			def self.find_all
+				RestClient.get File.join(@@config[:services]["opentox-model"], 'lazar_classification')#.split("\n")
+			end
+
+			# Predict a compound
+			def predict(compound)
+				LazarPrediction.new(:uri => RestClient.post(@uri, :compound_uri => compound.uri))
+			end
+
+			def self.base_uri
+				@@config[:services]["opentox-model"]
+			end
+
+		end
+
+	end
+
+	module Prediction
+
+		module Classification
+
+			class Lazar < OpenTox
+
+				def initialize(params)
+					super(params[:uri])
+				end
+
+				def classification
+					YAML.load(RestClient.get @uri)[:classification]
+				end
+
+				def confidence
+					YAML.load(RestClient.get @uri)[:confidence]
+				end
+
+				def neighbors
+					RestClient.get @uri + '/neighbors' 
+				end
+
+				def features
+					RestClient.get @uri + '/features' 
+				end
+
+			end
+
+		end
+
+	end
+end