bio-basespace-sdk 0.1.2

data/examples/4_app_result_upload.rb

@@ -0,0 +1,102 @@
+#!/usr/bin/env ruby
+
+# Copyright 2013 Toshiaki Katayama, Joachim Baran
+#
+#     Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# http://www.apache.org/licenses/LICENSE-2.0
+# 
+#     Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Creating an AppResult and uploading files
+#   https://developer.basespace.illumina.com/docs/content/documentation/sdk-samples/python-sdk-overview#Creating_an_AppResult_and_uploading_files
+
+require 'basespace'
+
+include Bio::BaseSpace
+
+# This script demonstrates how to create a new AppResults object, change its state
+# and upload result files to it and download files from it.  
+
+opts = {
+  # FILL IN WITH YOUR APP VALUES HERE!
+  'client_id'       => '<your client key>',
+  'client_secret'   => '<your client secret>',
+  'access_token'    => '<your access token>',
+  'app_session_id'  => '<app session id>',
+  'basespace_url'   => 'https://api.basespace.illumina.com/',
+  'api_version'     => 'v1pre3',
+}
+
+# Test if client variables have been set.
+unless opts.select{|k,v| v[/^<.*>$/]}.empty?
+  opts = Bio::BaseSpace.load_credentials
+  exit 1 unless opts
+end
+
+# First, create a client for making calls for this user session.
+bs_api = BaseSpaceAPI.new(opts['client_id'], opts['client_secret'], opts['basespace_url'], opts['api_version'], opts['app_session_id'], opts['access_token'])
+
+# Now we'll do some work of our own. First get a project to work on.
+# We need write permission for the project we are working on,
+# meaning we will need get a new token and instantiate a new BaseSpaceAPI.
+prj = bs_api.get_project_by_id('89')  # [TODO] Original ID '89' was not accessible. Writable project is needed.
+
+# Assuming we have write access to the project
+# we list the current App Results for the project.
+statuses = ['Running']
+app_res = prj.get_app_results(bs_api, {}, statuses)  # [TODO] should introduce hash options / keyword arguments (in Ruby 2.0)
+puts "The current running AppResults are #{app_res}"
+puts
+
+#
+# Retrieving results and setting status
+#
+
+# To create an appResults for a project, simply give the name and description.
+app_results = prj.create_app_result(bs_api, "testing", "this is my results")
+puts "Some info about our new app results"
+puts app_results
+puts app_results.id
+puts
+puts "The app results also comes with a reference to our AppSession"
+my_app_session = app_results.app_session
+puts my_app_session
+puts
+
+# We can change the status of our AppSession and add a status-summary as follows.
+my_app_session.set_status(bs_api, 'needsattention', "We worked hard, but encountered some trouble.")
+puts "After a change of status of the app sessions we get #{my_app_session}"
+puts
+# We set our appSession back to running so we can do some more work.
+my_app_session.set_status(bs_api, 'running', "Back on track")
+
+
+# Let's list all AppResults again and see if our new object shows up.
+app_res = prj.get_app_results(bs_api, {}, ['Running'])
+puts "The updated app results are #{app_res}"
+app_result2 = bs_api.get_app_result_by_id(app_results.id)
+puts app_result2
+puts
+
+# Now we will make another AppResult and try to upload a file to it
+app_results2 = prj.create_app_result(bs_api, "My second AppResult", "This one I will upload to")
+app_results2.upload_file(bs_api, '/home/mkallberg/Desktop/testFile2.txt', 'BaseSpaceTestFile.txt', '/mydir/', 'text/plain')
+puts "My AppResult number 2 #{app_results2}"
+puts
+
+# Let's see if our new file made it.
+app_result_files = app_results2.get_files(bs_api)
+puts "These are the files in the appResult"
+puts app_result_files
+f = app_result_files.last
+
+# We can even download our newly uploaded file.
+f = bs_api.get_file_by_id(f.id)
+f.download_file(bs_api, '/home/mkallberg/Desktop/')
+

data/examples/5_purchasing.rb

@@ -0,0 +1,119 @@
+#!/usr/bin/env ruby
+
+# Copyright 2013 Toshiaki Katayama, Joachim Baran
+#
+#     Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# http://www.apache.org/licenses/LICENSE-2.0
+# 
+#     Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'basespace'
+
+include Bio::BaseSpace
+
+# This example demonstrates the billing methods of BaseSpace.
+# 
+# Below a purchase is created, requiring the user to click 'Purchase' in a web
+# browser. The purchase is then refunded, and the purchase is again retrieved
+# via the API using the purchase id and tags, which are used by developers
+# to help clarify exactly what was purchased.
+# 
+# NOTE You will need to fill client values for your app below!
+
+opts = {
+  # FILL IN WITH YOUR APP VALUES HERE!
+  'client_id'            => '<your client key>',     # from dev portal app Credentials tab
+  'client_secret'        => '<your client secret>',  # from dev portal app Credentials tab
+  'access_token'         => '<your access token>',   # from oauth2
+  'app_session_id'       => '<app session id>',      # from launching an app
+  'basespace_url'        => 'https://api.basespace.illumina.com/',
+  'api_version'          => 'v1pre3',
+  'basespace_store_url'  => 'https://hoth-store.basespace.illumina.com/',
+  'product_id'           => '',                      # from dev portal Pricing tab
+}
+
+# Test if client variables have been set.
+unless opts.select{|k,v| v[/^<.*>$/]}.empty?
+  opts = Bio::BaseSpace.load_credentials
+  exit 1 unless opts
+end
+
+unless opts['client_id'] or opts['product_id']
+  raise "Please fill in client values (in the script) before running the script"
+end
+
+# First, create a client for making calls for this user session.
+bill_api = BillingAPI.new(opts['basespace_store_url'], opts['api_version'], opts['app_session_id'], opts['access_token'])
+
+# Create a non-consumable purchase.
+#purch = bill_api.create_purchase([{'id':product_id,'quantity':4 }])
+
+# Create a consumable purchase, and associated it with an AppSession
+# also add tags to provide (fake) details about the purchase.
+puts "Creating purchase"
+# purch = billAPI.createPurchase({'id':product_id,'quantity':4, 'tags':["test","test_tag"] }, AppSessionId)
+products = {
+  'id'        => opts['product_id'],
+  'quantity'  => 4,
+  'tags'      => ["test", "test_tag"],
+}
+purch = bill_api.create_purchase(products, opts['app_session_id'])
+
+# Record the purchase Id and RefundSecret for refunding later.
+purchase_id    = purch.id
+refund_secret  = purch.refund_secret
+
+puts "Now complete the purchase in your web browser"
+puts "CLOSE the browser window/tab after you click 'Purchase' (and don't proceed into the app)"
+time.sleep(3)
+## PAUSE HERE
+link = purch.href_purchase_dialog
+puts "Opening: #{link}"
+host = RbConfig::CONFIG['host_os']
+case host
+when /mswin|mingw|cygwin/
+  system("start #{link}")
+when /darwin/
+  system("open #{link}")
+when /linux/
+  system("xdg-open #{link}")
+end
+puts "Waiting 30 seconds..."
+time.sleep(30)
+## PAUSE HERE
+
+puts "Confirm the purchase"
+post_purch = bill_api.get_purchase_by_id(purchase_id)
+puts "The status of the purchase is now: " + post_purch.status
+puts
+
+puts "Refunding the Purchase"
+puts
+# NOTE We must use the same access token that was provided used for the purchase.
+refunded_purchase = bill_api.refund_purchase(purchase_id, refund_secret, 'the product did not function well as a frisbee')
+
+puts "Getting all purchases for the current user with the tags we used for the purchase above"
+puts
+#purch_prods = bill_api.get_user_products
+purch_prods = bill_api.get_user_products('current', {'Tags' => 'test,test_tag'})
+if purch_prods.nil? or purch_prods.empty?
+  puts "Hmmm, didn't find any purchases with these tags. Did everything go OK above?"
+else
+  puts "For the first of these purchases:"
+  puts "Purchase Name: #{purch_prods[0].name}"
+  puts "Purchase Price: #{purch_prods[0].price}"
+  puts "Purchase Quantity: #{purch_prods[0].quantity}"
+  puts "Tags: #{purch_prods[0].tags}"
+  # Get the refund status of the purchase
+  puts "Getting the (refunded) Purchase we just made"
+  get_purch = bill_api.get_purchase_by_id(purch_prods[0].purchase_id)
+  puts "Refund Status: #{get_purch.refund_status}"
+end
+
+

data/lib/basespace.rb

@@ -0,0 +1,126 @@
+# Copyright 2012-2013 Joachim Baran, Raoul Bonnal, Toshiaki Katayama, Francesco Strozzi
+#
+#     Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# http://www.apache.org/licenses/LICENSE-2.0
+# 
+#     Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Still need to check [TODO] sections
+
+require 'basespace/api/api_client'
+require 'basespace/api/base_api'
+require 'basespace/api/billing_api'
+require 'basespace/api/basespace_api'
+require 'basespace/api/basespace_error'
+
+require 'basespace/model'
+require 'basespace/model/app_result'
+require 'basespace/model/app_result_response'
+require 'basespace/model/app_session'
+require 'basespace/model/app_session_compact'
+require 'basespace/model/app_session_launch_object'
+require 'basespace/model/app_session_response'
+require 'basespace/model/application'
+require 'basespace/model/application_compact'
+require 'basespace/model/basespace_model'
+require 'basespace/model/coverage'
+require 'basespace/model/coverage_meta_response'
+require 'basespace/model/coverage_metadata'
+require 'basespace/model/coverage_response'
+require 'basespace/model/file'
+require 'basespace/model/file_response'
+require 'basespace/model/genome_response'
+require 'basespace/model/genome_v1'
+require 'basespace/model/list_response'
+#require 'basespace/model/multipart_upload'
+require 'basespace/model/product'
+require 'basespace/model/project'
+require 'basespace/model/project_response'
+require 'basespace/model/purchase'
+require 'basespace/model/purchase_response'
+require 'basespace/model/purchased_product'
+require 'basespace/model/query_parameters'
+require 'basespace/model/query_parameters_purchased_product'
+require 'basespace/model/refund_purchase_response'
+require 'basespace/model/resource_list'
+require 'basespace/model/response_status'
+require 'basespace/model/run_compact'
+require 'basespace/model/sample'
+require 'basespace/model/sample_response'
+require 'basespace/model/user'
+require 'basespace/model/user_compact'
+require 'basespace/model/user_response'
+require 'basespace/model/variant'
+require 'basespace/model/variant_header'
+require 'basespace/model/variant_info'
+require 'basespace/model/variants_header_response'
+
+require 'json'
+
+module Bio
+
+  # BaseSpace Ruby SDK is to be used in the development of Apps and scripts
+  # for working with Illumina's BaseSpace cloud-computing solution for next-gen
+  # sequencing data analysis.
+  module BaseSpace
+
+    # Loads login and authentication credentials from a JSON file.
+    # 
+    # If the environment variable "BASESPACE_CREDENTIALS" is set, then the
+    # path to the JSON files is taken from there. Otherwise, the current
+    # directory is searched for the file "credentials.json".
+    #
+    # On success, returns a hash with the values for
+    # * client_id
+    # * client_secret
+    # * access_token
+    # * app_session_id
+    # * basespace_url
+    # * api_version
+    #
+    # On failure, returns nil.
+    def self.load_credentials
+      filename = "credentials.json"
+      if ENV['BASESPACE_CREDENTIALS']
+        jsonfile = ENV['BASESPACE_CREDENTIALS']
+      else
+        jsonfile = ::File.join('.', filename)
+      end
+      if ::File.exists?(jsonfile)
+        hash = JSON.parse(::File.read(jsonfile))
+        if $DEBUG
+          $stderr.puts "    # ----- Bio::BaseSpace.load_credientials ----- "
+          $stderr.puts "    # Loaded credentials from #{jsonfile}"
+          $stderr.puts "    # "
+        end
+      else
+        hash = nil
+        $stderr.puts "    # ----- Bio::BaseSpace.load_credientials ----- "
+        $stderr.puts "    # You can put your credentials for the BaseSpace in the"
+        $stderr.puts "    #   #{jsonfile}"
+        $stderr.puts "    # file or point to the file with an environmental variable"
+        $stderr.puts "    #   export BASESPACE_CREDENTIALS=/path/to/your/#{filename}"
+        $stderr.puts "    # in the following format:"
+        data = {
+          'client_id'       => '<your client id>',
+          'client_secret'   => '<your client secret>',
+          'access_token'    => '<your access token>',
+          'app_session_id'  => '<app session id>',
+          'basespace_url'   => 'https://api.basespace.illumina.com/',
+          'api_version'     => 'v1pre3',
+        }
+        $stderr.puts JSON.pretty_generate(JSON.parse(data.to_json))
+      end
+      return hash
+    end
+
+  end # BaseSpace
+end # Bio
+
+

data/lib/basespace/api/api_client.rb

@@ -0,0 +1,313 @@
+# Copyright 2012-2013 Joachim Baran, Toshiaki Katayama
+#
+#     Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# http://www.apache.org/licenses/LICENSE-2.0
+# 
+#     Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'basespace/api/basespace_error'
+
+require 'net/https'
+require 'uri'
+require 'json'
+require 'date'
+
+Net::HTTP.version_1_2
+
+module Bio
+module BaseSpace
+
+# This class provides wrapper methods to the BaseSpace API RESTful interface. It also
+# handles serialization and deserialization of objects (Ruby to/from JSON). It is primarily
+# used as a helper class for BaseSpaceAPI.
+class APIClient
+  attr_accessor :api_key, :api_server, :timeout
+
+  # Create a new instance that will carry out REST calls.
+  #
+  # +access_token+:: Access token that is provided by App triggering.
+  # +api_server+:: URI of the BaseSpace API server.
+  # +timeout+:: Timeout for REST calls.
+  def initialize(access_token = nil, api_server = nil, timeout = 10)
+    if $DEBUG
+      $stderr.puts "    # ----- BaseAPI#initialize ----- "
+      $stderr.puts "    # caller: #{caller}"
+      $stderr.puts "    # access_token: #{access_token}"
+      $stderr.puts "    # api_server: #{api_server}"
+      $stderr.puts "    # timeout: #{timeout}"
+      $stderr.puts "    # "
+    end
+    raise UndefinedParameterError.new('AccessToken') unless access_token
+    @api_key = access_token
+    @api_server = api_server
+    @timeout = timeout
+  end
+
+  # POST data to a provided URI.
+  #
+  # +resource_path+:: URI to which the data should be POSTed.
+  # +post_data+:: Hash that contains the data.
+  # +headers+:: Header of the POST call.
+  # +data+:: (unused; TODO)
+  def force_post_call(resource_path, post_data, headers, data = nil)
+    # [TODO] Confirm whether we can expect those two parameters are Hash objects:
+    # headers = { "key" => "value" }
+    # post_data = { "key" => "value" }
+    uri = URI.parse(resource_path)
+    # If headers are not needed, the following line should be enough:
+    # return Net::HTTP.post_form(uri, post_data).body
+    http_opts = {}
+    if uri.scheme == "https"
+      http_opts[:use_ssl] = true
+    end
+    res = Net::HTTP.start(uri.host, uri.port, http_opts) { |http|
+      encoded_data = hash2urlencode(post_data)
+      http.post(uri.path, encoded_data, headers)
+    }
+    return res.body
+  end
+
+  # URL encode a Hash of data values.
+  #
+  # +hash+:: data encoded in a Hash.
+  def hash2urlencode(hash)
+    # URI.escape (alias URI.encode) is obsolete since Ruby 1.9.2.
+    #return hash.map{|k,v| URI.encode(k.to_s) + "=" + URI.encode(v.to_s)}.join("&")
+    return hash.map{|k,v| URI.encode_www_form_component(k.to_s) + "=" + URI.encode_www_form_component(v.to_s)}.join("&")
+  end
+
+  # Makes a PUT call to a given URI for depositing file contents.
+  #
+  # +resource_path+:: URI to which the data should be transferred.
+  # +post_data+:: (unused; TODO)
+  # +headers+:: Header of the PUT call.
+  # +trans_file+:: Path to the file that should be transferred.
+  def put_call(resource_path, post_data, headers, trans_file)
+    return %x(curl -H "x-access-token:#{@api_key}" -H "Content-MD5:#{headers['Content-MD5'].strip}" -T "#{trans_file}" -X PUT #{resource_path})
+  end
+
+  # Deserialize a boolean value to a Ruby object.
+  #
+  # +value+:: serialized representation of the boolean value.
+  def bool(value)
+    case value
+    when nil, false, 0, 'nil', 'false', '0', 'None'
+      result = false
+    else
+      result = true
+    end
+    return result
+  end
+
+  # Carries out a RESTful operation on the BaseSpace API.
+  #
+  # TODO Need check. Logic in this method is rather complicated...
+  #
+  # +resource_path+:: URI that should be used for the API call.
+  # +method+:: HTTP method for the rest call (GET, POST, DELETE, etc.)
+  # +query_params+:: query parameters that should be sent along to the API.
+  # +post_data+:: Hash that contains data to be transferred.
+  # +header_params+:: Additional settings that should be transferred in the HTTP header.
+  # +force_post+:: Truth value that indicates whether a POST should be forced.
+  def call_api(resource_path, method, query_params, post_data, header_params = nil, force_post = false)
+    url = @api_server + resource_path
+
+    headers = header_params.dup
+    headers['Content-Type'] = 'application/json' if not headers.has_key?('Content-Type') and not method == 'PUT'
+    # include access token in header
+    headers['Authorization'] = "Bearer #{@api_key}"
+
+    uri = request = response = data = cgi_params = nil
+
+    if query_params
+      # Need to remove None (in Python, nil in Ruby) values, these should not be sent
+      sent_query_params = {}
+      query_params.each do |param, value|
+        sent_query_params[param] = value if bool(value)
+      end
+      cgi_params = hash2urlencode(sent_query_params)
+    end
+
+    if $DEBUG
+      $stderr.puts "    # ----- APIClient#call_api ----- "
+      $stderr.puts "    # caller: #{caller}"
+      $stderr.puts "    # url: #{url}"
+      $stderr.puts "    # method: #{method}"
+      $stderr.puts "    # headers: #{headers}"
+      $stderr.puts "    # cgi_params: #{cgi_params}"
+      $stderr.puts "    # post_data: #{post_data}"
+      $stderr.puts "    # "
+    end
+
+    case method
+    when 'GET'
+      if cgi_params
+        url += "?#{cgi_params}"
+      end
+      # [TODO] confirm this works or not
+      #request = urllib2.Request(url, headers)
+      uri = URI.parse(url)
+      request = Net::HTTP::Get.new(uri.path, headers)
+    when 'POST', 'PUT', 'DELETE'
+      if cgi_params
+        force_post_url = url 
+        url += "?#{cgi_params}"
+      end
+      if post_data
+        # [TODO] Do we need to skip String, Integer, Float and bool in Ruby?
+        data = post_data.to_json # if not [str, int, float, bool].include?(type(post_data))
+      end
+      if force_post
+        response = force_post_call(force_post_url, sent_query_params, headers)
+      else
+        data = '\n' if data and data.empty? # temp fix, in case is no data in the file, to prevent post request from failing
+        # [TODO] confirm this works or not
+        #request = urllib2.Request(url, headers, data)#, @timeout)
+        uri = URI.parse(url)
+        request = Net::HTTP::Post.new(uri.path, headers)
+      end
+      if ['PUT', 'DELETE'].include?(method) # urllib doesnt do put and delete, default to pycurl here
+        response = put_call(url, query_params, headers, data)
+        response = response.split.last
+      end
+    else
+      raise "Method #{method} is not recognized."
+    end
+
+    # Make the request, request may raise 403 forbidden, or 404 non-response
+    if not force_post and not ['PUT', 'DELETE'].include?(method)  # the normal case
+      # puts url
+      # puts request
+      # puts "request with timeout=#{@timeout}"
+      # [TODO] confirm this works or not
+      #response = urllib2.urlopen(request, @timeout).read()
+      http_opts = {}
+      if uri.scheme == "https"
+        http_opts[:use_ssl] = true
+      end
+      response = Net::HTTP.start(uri.host, uri.port, http_opts) { |http|
+        http.request(request)
+      }
+    end
+            
+    begin
+      data = JSON.parse(response.body)
+    rescue => err
+      $stderr.puts "    # ----- APIClient#call_api ----- "
+      $stderr.puts "    # Error: #{err}"
+      $stderr.puts "    # "
+      data = nil
+    end
+    return data
+  end
+
+  # Serialize a list to a CSV string, if necessary.
+  #
+  # +obj+:: Data object to be serialized.
+  def to_path_value(obj)
+    if obj.kind_of?(Array)
+      return obj.join(',')
+    else
+      return obj
+    end
+  end
+
+  # Deserialize a JSON string into an object.
+  #
+  # +obj+:: String or object to be deserialized.
+  # +obj_class+:: Class literal for deserialzied object, or string of class name.
+  def deserialize(obj, obj_class)
+    case obj_class.downcase
+    when 'str'
+      return obj.to_s
+    when 'int'
+      return obj.to_i
+    when 'float'
+      return obj.to_f
+    when 'bool'
+      return bool(obj)
+    when 'file'
+      # Bio::BaseSpace::File
+      instance = File.new 
+    else
+      # models in BaseSpace
+      klass = Object.const_get(obj_class)
+      instance = klass.new
+    end
+
+    if $DEBUG
+      $stderr.puts "    # ----- APIClient#deserialize ----- "
+      $stderr.puts "    # caller: #{caller}"
+      $stderr.puts "    # obj_class: #{obj_class}"
+      $stderr.puts "    # obj: #{obj}"  # JSON.pretty_generate(obj)
+      $stderr.puts "    # "
+    end
+
+    instance.swagger_types.each do |attr, attr_type|
+      if obj.has_key?(attr) or obj.has_key?(attr.to_s)
+        if $DEBUG
+          $stderr.puts "    # # ----- APIClient#deserialize/swagger_types ----- "
+          $stderr.puts "    # # attr: #{attr}"
+          $stderr.puts "    # # attr_type: #{attr_type}"
+          $stderr.puts "    # # value: #{obj[attr]}"
+          $stderr.puts "    # # "
+        end
+        value = obj[attr]
+        case attr_type.downcase
+        when 'str'
+          instance.set_attr(attr, value.to_s)
+        when 'int'
+          instance.set_attr(attr, value.to_i)
+        when 'float'
+          instance.set_attr(attr, value.to_f)
+        when 'datetime'
+          instance.set_attr(attr, DateTime.parse(value))
+        when 'bool'
+          instance.set_attr(attr, bool(value))
+        when /list</
+          sub_class = attr_type[/list<(.*)>/, 1]
+          sub_values = []
+          value.each do |sub_value|
+            sub_values << deserialize(sub_value, sub_class)
+          end
+          instance.set_attr(attr, sub_values)
+        when 'dict'  # support for parsing dictionary
+          if $DEBUG
+            $stderr.puts "    # # # ----- APIClient#deserialize/swagger_types/dict ----- "
+            $stderr.puts "    # # # dict: #{value}"
+            $stderr.puts "    # # # "
+          end
+          # [TODO] May need to convert value -> Hash (check in what format the value is passed)
+          instance.set_attr(attr, value)
+        else
+          if $DEBUG
+            # print "recursive call w/ " + attrType
+            $stderr.puts "    # # # ----- APIClient#deserialize/swagger_types/recursive call ----- "
+            $stderr.puts "    # # # attr: #{attr}"
+            $stderr.puts "    # # # attr_type: #{attr_type}"
+            $stderr.puts "    # # # value: #{value}"
+            $stderr.puts "    # # # "
+          end
+          instance.set_attr(attr, deserialize(value, attr_type))
+        end
+      end
+    end
+    if $DEBUG
+      $stderr.puts "    # # ----- APIClient#deserialize/instance ----- "
+      $stderr.puts "    # # instance: #{instance.attributes.inspect}"
+      $stderr.puts "    # # "
+    end
+    return instance
+  end
+
+end
+
+end # module BaseSpace
+end # module Bio
+