opentox-client 0.0.1pre → 0.0.2pre

data/README.markdown

@@ -3,6 +3,11 @@ opentox-ruby-minimal
 
 Thin Ruby wrapper for the [OpenTox](http://www.opentox.org) REST API 
 
+Dependencies
+------------
+
+  libraptor1-dev
+
 Installation
 ------------
 

data/lib/authorization.rb

@@ -1,21 +1,22 @@
 module OpenTox
-
+  AA = $aa[:uri] if defined? $aa
+  AA ||= "https://opensso.in-silico.ch" #if not set in .opentox/conf/[application]/[test].rb
   #Module for Authorization and Authentication
   #@example Authentication
   #  require "opentox-client"
-  #  OpenTox::Authorization::AA_SERVER = "https://opensso.in-silico.ch" #if not set in .opentox/conf/[environment].yaml 
-  #  token = OpenTox::Authorization.authenticate("benutzer", "passwort")
+  #  OpenTox::Authorization::AA = "https://opensso.in-silico.ch" #if not set in .opentox/conf/[environment].yaml
+  #  token = OpenTox::Authorization.authenticate("username", "password")
   #@see http://www.opentox.org/dev/apis/api-1.2/AA OpenTox A&A API 1.2 specification
 
   module Authorization
 
-    #Helper Class AA to create and send default policies out of xml templates
+    #Helper Class to create and send default policies out of xml templates
     #@example Creating a default policy to a URI
     #  aa=OpenTox::Authorization::AA.new(tok)
     #  xml=aa.get_xml('http://uri....')
     #  OpenTox::Authorization.create_policy(xml,tok)
 
-    class AA
+    class Helper
       attr_accessor :user, :subjectid, :policy
 
       #Generates AA object - requires subjectid
@@ -41,27 +42,27 @@ module OpenTox
         xml = get_xml(uri)
         ret = false
         ret = Authorization.create_policy(xml, @subjectid)
-        @@logger.debug "Policy send with subjectid: #{@subjectid}"
-        @@logger.warn "Not created Policy is: #{xml}" if !ret
+        $logger.warn "Create policy on openSSO failed for URI: #{uri} subjectid: #{@subjectid}. Will try again." if !ret
+        ret = Authorization.create_policy(xml, @subjectid) if !ret
+        $logger.debug "Policy send with subjectid: #{@subjectid}"
+        $logger.error "Not created Policy is: #{xml}" if !ret
         ret
       end
-
     end
 
     #Returns the open-sso server set in the config file .opentox/config/[environment].yaml
     # @return [String, nil] the openSSO server URI or nil
     def self.server
-      return AA_SERVER
+      return AA
     end
 
     #Authentication against OpenSSO. Returns token. Requires Username and Password.
     # @param [String, String]Username,Password
     # @return [String, nil] gives subjectid or nil
     def self.authenticate(user, pw)
-      return nil if !AA_SERVER
+      return nil if !AA
       begin
-        resource = RestClient::Resource.new("#{AA_SERVER}/auth/authenticate")
-        out = resource.post(:username=>user, :password => pw).sub("token.id=","").sub("\n","")
+        out = RestClientWrapper.post("#{AA}/auth/authenticate",{:username=>user, :password => pw}).sub("token.id=","").sub("\n","")
         return out
       rescue
         return nil
@@ -73,22 +74,21 @@ module OpenTox
     # @return [Boolean] true if logout is OK
     def self.logout(subjectid)
       begin
-        resource = RestClient::Resource.new("#{AA_SERVER}/auth/logout")
-        resource.post(:subjectid => subjectid)
-        return true
+        out = RestClientWrapper.post("#{AA}/auth/logout",:subjectid => subjectid)
+        return true unless is_token_valid(subjectid)
       rescue
         return false
       end
+      return false
     end
 
     #Authorization against OpenSSO for a URI with request-method (action) [GET/POST/PUT/DELETE]
     # @param [String,String,String]uri,action,subjectid
     # @return [Boolean, nil]  returns true, false or nil (if authorization-request fails).
     def self.authorize(uri, action, subjectid)
-      return true if !AA_SERVER
+      return true if !AA
       begin
-        resource = RestClient::Resource.new("#{AA_SERVER}/auth/authorize")
-        return true if resource.post(:uri => uri, :action => action, :subjectid => subjectid) == "boolean=true\n"
+        return true if RestClientWrapper.post("#{AA}/auth/authorize",{:uri => uri, :action => action, :subjectid => subjectid})== "boolean=true\n"
       rescue
         return nil
       end
@@ -98,13 +98,13 @@ module OpenTox
     # @param [String]subjectid subjectid from openSSO session
     # @return [Boolean] subjectid is valid or not.
     def self.is_token_valid(subjectid)
-      return true if !AA_SERVER
+      return true if !AA
       begin
-        resource = RestClient::Resource.new("#{AA_SERVER}/auth/isTokenValid")
-        return true if resource.post(:tokenid => subjectid) == "boolean=true\n"
+        return true if RestClientWrapper.post("#{AA}/auth/isTokenValid",:tokenid => subjectid) == "boolean=true\n"
       rescue
         return false
       end
+      return false
     end
 
     #Returns array with all policies of the token owner
@@ -112,11 +112,8 @@ module OpenTox
     # @return [Array, nil] returns an Array of policy names or nil if request fails
     def self.list_policies(subjectid)
       begin
-        resource = RestClient::Resource.new("#{AA_SERVER}/pol")
-        out = resource.get(:subjectid => subjectid)
+        out = RestClientWrapper.get("#{AA}/pol",nil,:subjectid => subjectid)
         return out.split("\n")
-      rescue RestClient::InternalServerError => e
-        raise e.response
       rescue
         return nil
       end
@@ -127,8 +124,7 @@ module OpenTox
     # @return [String] XML of the policy
     def self.list_policy(policy, subjectid)
       begin
-        resource = RestClient::Resource.new("#{AA_SERVER}/pol")
-        return resource.get(:subjectid => subjectid,:id => policy)
+        return RestClientWrapper.get("#{AA}/pol",nil,{:subjectid => subjectid,:id => policy})
       rescue
         return nil
       end
@@ -160,8 +156,7 @@ module OpenTox
     # return [String, nil]owner,nil returns owner of the URI
     def self.get_uri_owner(uri, subjectid)
       begin
-        resource = RestClient::Resource.new("#{AA_SERVER}/pol")
-        return resource.get(:uri => uri, :subjectid => subjectid).sub("\n","")
+        return RestClientWrapper.get("#{AA}/pol",nil,{:subjectid => subjectid, :uri => uri}).sub("\n","")
       rescue
         return nil
       end
@@ -181,8 +176,7 @@ module OpenTox
     # return [Array, nil] returns an Array of policy names or nil if request fails
     def self.list_uri_policies(uri, subjectid)
       begin
-        resource = RestClient::Resource.new("#{AA_SERVER}/pol")
-        out = resource.get(:uri => uri, :polnames => true, :subjectid => subjectid)
+        out = RestClientWrapper.get("#{AA}/pol",nil,{:uri => uri, :polnames => true, :subjectid => subjectid})
         policies = []; notfirstline = false
         out.split("\n").each do |line|
           policies << line if notfirstline
@@ -199,9 +193,8 @@ module OpenTox
     # return [Boolean] returns true if policy is created
     def self.create_policy(policy, subjectid)
       begin
-        resource = RestClient::Resource.new("#{AA_SERVER}/Pol/opensso-pol")
-        @@logger.debug "OpenTox::Authorization.create_policy policy: #{policy[168,43]} with token:" + subjectid.to_s + " length: " + subjectid.length.to_s 
-        return true if resource.post(policy, :subjectid => subjectid, :content_type =>  "application/xml")
+        $logger.debug "OpenTox::Authorization.create_policy policy: #{policy[168,43]} with token:" + subjectid.to_s + " length: " + subjectid.length.to_s
+        return true if RestClientWrapper.post("#{AA}/Pol/opensso-pol",policy, {:subjectid => subjectid, :content_type =>  "application/xml"})
       rescue
         return false
       end
@@ -212,36 +205,19 @@ module OpenTox
     # @return [Boolean,nil]
     def self.delete_policy(policy, subjectid)
       begin
-        resource = RestClient::Resource.new("#{AA_SERVER}/pol")
-        @@logger.debug "OpenTox::Authorization.delete_policy policy: #{policy} with token: #{subjectid}"
-        return true if resource.delete(:subjectid => subjectid, :id => policy)
+        $logger.debug "OpenTox::Authorization.delete_policy policy: #{policy} with token: #{subjectid}"
+        return true if RestClientWrapper.delete("#{AA}/pol",nil, {:subjectid => subjectid, :id => policy})
       rescue
         return nil
       end
     end
 
-    #Returns array of all possible LDAP-Groups
-    # @param [String]subjectid
-    # @return [Array]
-    def self.list_groups(subjectid)
-      begin
-        resource = RestClient::Resource.new("#{AA_SERVER}/opensso/identity/search")
-        grps = resource.post(:admin => subjectid, :attributes_names => "objecttype", :attributes_values_objecttype => "group")
-        grps = grps.split("\n").collect{|x|  x.sub("string=","")}
-        grps.delete_if{|g|g=="MemberManagement"||g=="Webmasters"}
-        grps
-      rescue
-        []
-      end
-    end
-
     #Returns array of the LDAP-Groups of an user
     # @param [String]subjectid
     # @return [Array] gives array of LDAP groups of a user
     def self.list_user_groups(user, subjectid)
       begin
-        resource = RestClient::Resource.new("#{AA_SERVER}/opensso/identity/read")
-        out = resource.post(:name => user, :admin => subjectid, :attributes_names => "group")
+        out = RestClientWrapper.post("#{AA}/opensso/identity/read", {:name => user, :admin => subjectid, :attributes_names => "group"})
         grps = []
         out.split("\n").each do |line|
           grps << line.sub("identitydetails.group=","") if line.include?("identitydetails.group=")
@@ -257,8 +233,7 @@ module OpenTox
     # @return [String]user
     def self.get_user(subjectid)
       begin
-        resource = RestClient::Resource.new("#{AA_SERVER}/opensso/identity/attributes")
-        out = resource.post(:subjectid => subjectid, :attributes_names => "uid")
+        out = RestClientWrapper.post("#{AA}/opensso/identity/attributes", {:subjectid => subjectid, :attributes_names => "uid"})
         user = ""; check = false
         out.split("\n").each do |line|
           if check
@@ -273,13 +248,13 @@ module OpenTox
       end
     end
 
-    #Send default policy with Authorization::AA class
+    #Send default policy with Authorization::Helper class
     # @param [String, String]URI,subjectid
     def self.send_policy(uri, subjectid)
-      return true if !AA_SERVER
-      aa  = Authorization::AA.new(subjectid)
+      return true if !AA
+      aa  = Authorization::Helper.new(subjectid)
       ret = aa.send(uri)
-      @@logger.debug "OpenTox::Authorization send policy for URI: #{uri} | subjectid: #{subjectid} - policy created: #{ret}"
+      $logger.debug "OpenTox::Authorization send policy for URI: #{uri} | subjectid: #{subjectid} - policy created: #{ret}"
       ret
     end
 
@@ -291,7 +266,7 @@ module OpenTox
       if policies
         policies.each do |policy|
           ret = delete_policy(policy, subjectid)
-          @@logger.debug "OpenTox::Authorization delete policy: #{policy} - with result: #{ret}"
+          $logger.debug "OpenTox::Authorization delete policy: #{policy} - with result: #{ret}"
         end
       end
       return true
@@ -300,15 +275,15 @@ module OpenTox
     # Checks (if subjectid is valid) if a policy exist and create default policy if not
     # @param [String] uri
     # @param [String] subjectid
-    # @return [Boolean] true if policy checked/created successfully (or no uri/subjectid given), false else 
+    # @return [Boolean] true if policy checked/created successfully (or no uri/subjectid given), false else
     def self.check_policy(uri, subjectid)
       return true unless uri and subjectid
       token_valid = OpenTox::Authorization.is_token_valid(subjectid)
-      @@logger.debug "OpenTox::Authorization.check_policy with uri: #{uri}, subjectid: #{subjectid} is valid: #{token_valid}"
+      $logger.debug "OpenTox::Authorization.check_policy with uri: #{uri}, subjectid: #{subjectid} is valid: #{token_valid}"
       # check if subjectid is valid
       unless token_valid
         # abort if invalid
-        @@logger.error "OpenTox::Authorization.check_policy, subjectid NOT valid: #{subjectid}"
+        $logger.error "OpenTox::Authorization.check_policy, subjectid NOT valid: #{subjectid}"
         return false
       end
 
@@ -320,7 +295,7 @@ module OpenTox
         if authorize(uri, "POST", subjectid)
           true
        else
-          @@logger.error "OpenTox::Authorization.check_policy, already exists, but no POST-authorization with subjectid: #{subjectid}" 
+          $logger.error "OpenTox::Authorization.check_policy, already exists, but no POST-authorization with subjectid: #{subjectid}"
           false
         end
       end
@@ -337,35 +312,36 @@ module OpenTox
     # @param [String] subjectid
     # @return [Boolean] true if access granted, else otherwise
     def self.authorized?(uri, request_method, subjectid)
-      if CONFIG[:authorization][:free_request].include?(request_method)
-        #@@logger.debug "authorized? >>true<< (request is free), method: #{request_method}, URI: #{uri}, subjectid: #{subjectid}"
+      request_method = request_method.to_sym if request_method
+      if $aa[:free_request].include?(request_method)
+        #$logger.debug "authorized? >>true<< (request is free), method: #{request_method}, URI: #{uri}, subjectid: #{subjectid}"
         true
       elsif OpenTox::Authorization.free_uri?(uri, request_method)
-        #@@logger.debug "authorized? >>true<< (uris is free_uri), method: #{request_method}, URI: #{uri}, subjectid: #{subjectid}"
+        #$logger.debug "authorized? >>true<< (uris is free_uri), method: #{request_method}, URI: #{uri}, subjectid: #{subjectid}"
         true
-      elsif CONFIG[:authorization][:authenticate_request].include?(request_method)
+      elsif $aa[:authenticate_request].include?(request_method)
         ret = OpenTox::Authorization.is_token_valid(subjectid)
-        @@logger.debug "authorized? >>#{ret}<< (token is in/valid), method: #{request_method}, URI: #{uri}, subjectid: #{subjectid}" unless ret
+        $logger.debug "authorized? >>#{ret}<< (token is in/valid), method: #{request_method}, URI: #{uri}, subjectid: #{subjectid}" unless ret
         ret
       elsif OpenTox::Authorization.authorize_exception?(uri, request_method)
         ret = OpenTox::Authorization.is_token_valid(subjectid)
-        @@logger.debug "authorized? >>#{ret}<< (uris is authorize exception, token is in/valid), method: #{request_method}, URI: #{uri}, subjectid: #{subjectid}" unless ret
+        $logger.debug "authorized? >>#{ret}<< (uris is authorize exception, token is in/valid), method: #{request_method}, URI: #{uri}, subjectid: #{subjectid}" unless ret
         ret
-      elsif CONFIG[:authorization][:authorize_request].include?(request_method)
+      elsif $aa[:authorize_request].include?(request_method)
         ret = OpenTox::Authorization.authorize(uri, request_method, subjectid)
-        @@logger.debug "authorized? >>#{ret}<< (uri (not) authorized), method: #{request_method}, URI: #{uri}, subjectid: #{subjectid}" unless ret
+        $logger.debug "authorized? >>#{ret}<< (uri (not) authorized), method: #{request_method}, URI: #{uri}, subjectid: #{subjectid}" unless ret
         ret
       else
-        @@logger.error "invalid request/uri method: #{request_method}, URI: #{uri}, subjectid: #{subjectid}"
+        $logger.error "invalid request/uri method: #{request_method}, URI: #{uri}, subjectid: #{subjectid}"
         false
       end
     end
 
     private
     def self.free_uri?(uri, request_method)
-      if CONFIG[:authorization][:free_uris]
-        CONFIG[:authorization][:free_uris].each do |request_methods,uris|
-          if request_methods and uris and request_methods.include?(request_method.to_sym)
+      if $aa[:free_uris]
+        $aa[:free_uris].each do |request_methods,uris|
+          if request_methods and uris and request_methods.include?(request_method.to_s)
             uris.each do |u|
               return true if u.match uri
             end
@@ -376,8 +352,8 @@ module OpenTox
     end
 
     def self.authorize_exception?(uri, request_method)
-      if CONFIG[:authorization][:authorize_exceptions]
-        CONFIG[:authorization][:authorize_exceptions].each do |request_methods,uris|
+      if $aa[:authorize_exceptions]
+        $aa[:authorize_exceptions].each do |request_methods,uris|
           if request_methods and uris and request_methods.include?(request_method.to_sym)
             uris.each do |u|
               return true if u.match uri

data/lib/dataset.rb

@@ -1,318 +1,29 @@
 module OpenTox
-  
+
   # Ruby wrapper for OpenTox Dataset Webservices (http://opentox.org/dev/apis/api-1.2/dataset).
-  # TODO: fix API Doc
   class Dataset 
 
-    #include OpenTox
-
-    #attr_reader :features, :compounds, :data_entries, :metadata
-
-    # Create dataset with optional URI. Does not load data into the dataset - you will need to execute one of the load_* methods to pull data from a service or to insert it from other representations.
-    # @example Create an empty dataset
-    #   dataset = OpenTox::Dataset.new
-    # @example Create an empty dataset with URI
-    #   dataset = OpenTox::Dataset.new("http:://webservices.in-silico/ch/dataset/1")
-    # @param [optional, String] uri Dataset URI
-    # @return [OpenTox::Dataset] Dataset object
-    def initialize(uri=nil,subjectid=nil)
-      super uri, subjectid
-      @features = {}
-      @compounds = []
-      @data_entries = {}
-    end
-
-=begin
-    # Load YAML representation into the dataset
-    # @param [String] yaml YAML representation of the dataset
-    # @return [OpenTox::Dataset] Dataset object with YAML data
-    def self.from_yaml service_uri, yaml, subjectid=nil
-      Dataset.create(service_uri, subjectid).post yaml, :content_type => "application/x-yaml"
-    end
-
-    # Load RDF/XML representation from a file
-    # @param [String] file File with RDF/XML representation of the dataset
-    # @return [OpenTox::Dataset] Dataset object with RDF/XML data
-    def self.from_rdfxml service_uri, rdfxml, subjectid=nil
-      Dataset.create(service_uri, subjectid).post rdfxml, :content_type => "application/rdf+xml"
-    end
-
-    # Load CSV string (format specification: http://toxcreate.org/help)
-    # - loads data_entries, compounds, features
-    # - sets metadata (warnings) for parser errors
-    # - you will have to set remaining metadata manually
-    # @param [String] csv CSV representation of the dataset
-    # @return [OpenTox::Dataset] Dataset object with CSV data
-    def self.from_csv service_uri, csv, subjectid=nil
-      Dataset.from_file(service_uri, csv, subjectid)
-    end
-
-    # Load Spreadsheet book (created with roo gem http://roo.rubyforge.org/, excel format specification: http://toxcreate.org/help)
-    # - loads data_entries, compounds, features
-    # - sets metadata (warnings) for parser errors
-    # - you will have to set remaining metadata manually
-    # @param [Excel] book Excel workbook object (created with roo gem)
-    # @return [OpenTox::Dataset] Dataset object with Excel data
-    def self.from_xls service_uri, xls, subjectid=nil
-      Dataset.create(service_uri, subjectid).post xls, :content_type => "application/vnd.ms-excel"
-    end
-    
-    def self.from_sdf service_uri, sdf, subjectid=nil
-      Dataset.create(service_uri, subjectid).post sdf, :content_type => 'chemical/x-mdl-sdfile'
-    end
-=end
-
-    # Load all data (metadata, data_entries, compounds and features) from URI
-    # TODO: move to opentox-server
-    def data_entries reload=true
-      if reload
-        file = Tempfile.new("ot-rdfxml")
-        file.puts get :accept => "application/rdf+xml"
-        file.close
-        to_delete = file.path
-            
-        data = {}
-        feature_values = {}
-        feature = {}
-        feature_accept_values = {}
-        other_statements = {}
-        `rapper -i rdfxml -o ntriples #{file.path} 2>/dev/null`.each_line do |line|
-          triple = line.chomp.split(' ',3)
-          triple = triple[0..2].collect{|i| i.sub(/\s+.$/,'').gsub(/[<>"]/,'')}
-          case triple[1] 
-          when /#{RDF::OT.values}|#{RDF::OT1.values}/i
-            data[triple[0]] = {:compound => "", :values => []} unless data[triple[0]]
-            data[triple[0]][:values] << triple[2]  
-          when /#{RDF::OT.value}|#{RDF::OT1.value}/i
-            feature_values[triple[0]] = triple[2] 
-          when /#{RDF::OT.compound}|#{RDF::OT1.compound}/i
-            data[triple[0]] = {:compound => "", :values => []} unless data[triple[0]]
-            data[triple[0]][:compound] = triple[2]
-          when /#{RDF::OT.feature}|#{RDF::OT1.feature}/i
-            feature[triple[0]] = triple[2]
-          when /#{RDF.type}/i
-            if triple[2]=~/#{RDF::OT.Compound}|#{RDF::OT1.Compound}/i and !data[triple[0]]
-              data[triple[0]] = {:compound => triple[0], :values => []} 
-            end
-          when /#{RDF::OT.acceptValue}|#{RDF::OT1.acceptValue}/i # acceptValue in ambit datasets is only provided in dataset/<id> no in dataset/<id>/features  
-            feature_accept_values[triple[0]] = [] unless feature_accept_values[triple[0]]
-            feature_accept_values[triple[0]] << triple[2]
-          else 
-          end
-        end
-        File.delete(to_delete) if to_delete
-        data.each do |id,entry|
-          if entry[:values].size==0
-            # no feature values add plain compounds
-            @compounds << entry[:compound] unless @compounds.include? entry[:compound]
-          else
-            entry[:values].each do |value_id|
-              if feature_values[value_id]
-                split = feature_values[value_id].split(/\^\^/)
-                case split[-1]
-                when RDF::XSD.double, RDF::XSD.float 
-                  value = split.first.to_f
-                when RDF::XSD.boolean
-                  value = split.first=~/(?i)true/ ? true : false                
-                else
-                  value = split.first
-                end
-              end
-              @compounds << entry[:compound] unless @compounds.include? entry[:compound]
-              @features[feature[value_id][value_id]] = {}  unless @features[feature[value_id]]
-              @data_entries[entry[:compound].to_s] = {} unless @data_entries[entry[:compound].to_s]
-              @data_entries[entry[:compound].to_s][feature[value_id]] = [] unless @data_entries[entry[:compound]][feature[value_id]]
-              @data_entries[entry[:compound].to_s][feature[value_id]] << value if value!=nil
-            end
-          end
-        end
-        features subjectid
-        #feature_accept_values.each do |feature, values|
-          #self.features[feature][OT.acceptValue] = values
-        #end
-        self.metadata = metadata(subjectid)
-      end
-      @data_entries
-    end
-
-    # Load and return only compound URIs from the dataset service
-    # @return [Array]  Compound URIs in the dataset
-    def compounds reload=true
-      reload ? @compounds = Compound.all(File.join(@uri,"compounds")) : @compounds
-    end
-
-    # Load and return only features from the dataset service
-    # @return [Hash]  Features of the dataset
-    def features reload=true
-      reload ? @features = Feature.all(File.join(@uri,"features")) : @features
-    end
-
-=begin
-    # returns the accept_values of a feature, i.e. the classification domain / all possible feature values 
-    # @param [String] feature the URI of the feature
-    # @return [Array] return array with strings, nil if value is not set (e.g. when feature is numeric)
-    def accept_values(feature)
-      load_features
-      accept_values = features[feature][OT.acceptValue]
-      accept_values.sort if accept_values
-      accept_values
-    end
-
-    # Detect feature type(s) in the dataset
-    # @return [String] `classification", "regression", "mixed" or unknown`
-    def feature_type
-      load_features
-      feature_types = @features.collect{|f,metadata| metadata[RDF.type]}.flatten.uniq
-      if feature_types.include?(OT.NominalFeature)
-        "classification"
-      elsif feature_types.include?(OT.NumericFeature)
-        "regression"
-      else
-        "unknown"
-      end
+    def data_entries
+      # TODO fix for api 1.2
+      data_entries = []
+      pull 
+      @reload = false
+      metadata[RDF::OT1.dataEntry].collect{|data_entry|
+        data_entries << @rdf.to_hash[data_entry]
+      }
+      @reload = true
+      data_entries
     end
-=end
 
-    # Get Excel representation (alias for to_spreadsheet)
-    # @return [Spreadsheet::Workbook] Workbook which can be written with the spreadsheet gem (data_entries only, metadata will will be discarded))
-    def to_xls
-      get :accept => "application/vnd.ms-excel"
+    def compounds
+      uri = File.join(@uri,"compounds")
+      RestClientWrapper.get(uri,{},{:accept => "text/uri-list", :subjectid => @subjectid}).split("\n").collect{|uri| OpenTox::Compound.new uri}
     end
 
-    # Get CSV string representation (data_entries only, metadata will be discarded)
-    # @return [String] CSV representation
-    def to_csv
-      get :accept => "text/csv"
+    def features
+      uri = File.join(@uri,"features")
+      RestClientWrapper.get(uri,{},{:accept => "text/uri-list", :subjectid => @subjectid}).split("\n").collect{|uri| OpenTox::Feature.new uri}
     end
 
-    def to_sdf
-      get :accept => 'chemical/x-mdl-sdfile'
-    end
-
-
-    # Get OWL-DL in ntriples format
-    # @return [String] N-Triples representation
-    def to_ntriples
-      get :accept => "application/rdf+xml"
-    end
-
-    # Get OWL-DL in RDF/XML format
-    # @return [String] RDF/XML representation
-    def to_rdfxml
-      get :accept => "application/rdf+xml"
-    end
-
-    # Get name (DC.title) of a feature
-    # @param [String] feature Feature URI
-    # @return [String] Feture title
-    def feature_name(feature)
-      features[feature][DC.title]
-    end
-
-    def title
-      metadata[DC.title]
-    end
-
-    # Insert a statement (compound_uri,feature_uri,value)
-    # @example Insert a statement (compound_uri,feature_uri,value)
-    #   dataset.add "http://webservices.in-silico.ch/compound/InChI=1S/C6Cl6/c7-1-2(8)4(10)6(12)5(11)3(1)9", "http://webservices.in-silico.ch/dataset/1/feature/hamster_carcinogenicity", true
-    # @param [String] compound Compound URI
-    # @param [String] feature Compound URI
-    # @param [Boolean,Float] value Feature value
-    def add (compound,feature,value)
-      @compounds << compound unless @compounds.include? compound
-      @features[feature] = {}  unless @features[feature]
-      @data_entries[compound] = {} unless @data_entries[compound]
-      @data_entries[compound][feature] = [] unless @data_entries[compound][feature]
-      @data_entries[compound][feature] << value if value!=nil
-    end
-
-    # Add a feature
-    # @param [String] feature Feature URI
-    # @param [Hash] metadata Hash with feature metadata
-    def add_feature(feature,metadata={})
-      @features[feature] = metadata
-    end
-
-    # Add/modify metadata for a feature
-    # @param [String] feature Feature URI
-    # @param [Hash] metadata Hash with feature metadata
-    def add_feature_metadata(feature,metadata)
-      metadata.each { |k,v| @features[feature][k] = v }
-    end
-    
-    # Add a new compound
-    # @param [String] compound Compound URI
-    def add_compound (compound)
-      @compounds << compound unless @compounds.include? compound
-    end
-    
-    # Creates a new dataset, by splitting the current dataset, i.e. using only a subset of compounds and features
-    # @param [Array] compounds List of compound URIs
-    # @param [Array] features List of feature URIs
-    # @param [Hash] metadata Hash containing the metadata for the new dataset
-    # @param [String] subjectid
-    # @return [OpenTox::Dataset] newly created dataset, already saved
-    def split( compounds, features, metadata)
-      LOGGER.debug "split dataset using "+compounds.size.to_s+"/"+@compounds.size.to_s+" compounds"
-      raise "no new compounds selected" unless compounds and compounds.size>0
-      dataset = OpenTox::Dataset.create(CONFIG[:services]["opentox-dataset"],@subjectid)
-      if features.size==0
-        compounds.each{ |c| dataset.add_compound(c) }
-      else
-        compounds.each do |c|
-          features.each do |f|
-            if @data_entries[c]==nil or @data_entries[c][f]==nil
-              dataset.add(c,f,nil)
-            else
-              @data_entries[c][f].each do |v|
-                dataset.add(c,f,v)
-              end
-            end
-          end
-        end
-      end
-      # set feature metadata in new dataset accordingly (including accept values)      
-      features.each do |f|
-        self.features[f].each do |k,v|
-          dataset.features[f][k] = v
-        end
-      end
-      dataset.add_metadata(metadata)
-      dataset.save
-      dataset
-    end
-
-    # Save dataset at the dataset service 
-    # - creates a new dataset if uri is not set
-    # - overwrites dataset if uri exists
-    # @return [String] Dataset URI
-    def save
-      @compounds.uniq!
-      # create dataset if uri is empty
-      self.uri = RestClientWrapper.post(CONFIG[:services]["opentox-dataset"],{:subjectid => @subjectid}).to_s.chomp unless @uri
-      if (CONFIG[:yaml_hosts].include?(URI.parse(@uri).host))
-        RestClientWrapper.post(@uri,self.to_yaml,{:content_type =>  "application/x-yaml", :subjectid => @subjectid})
-      else
-        s = Serializer::Owl.new
-        s.add_dataset(self)
-        RestClientWrapper.post(@uri, s.to_rdfxml,{:content_type => "application/rdf+xml" , :subjectid => @subjectid})
-      end
-      @uri
-    end
-
-    private
-    # Copy a dataset (rewrites URI)
-    def copy(dataset)
-      @metadata = dataset.metadata
-      @data_entries = dataset.data_entries
-      @compounds = dataset.compounds
-      @features = dataset.features
-      if @uri
-        self.uri = @uri 
-      else
-        @uri = dataset.metadata[XSD.anyURI]
-      end
-    end
   end
 end