predictionio 0.6.0 → 0.7.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4ff41097d6e2912ea649a62771deb609c9a3f025
+  data.tar.gz: 51a35d920b0918024faa2b51fbd4ed191582afba
+SHA512:
+  metadata.gz: 60eb1cabaf2fea7df32447b602af24545731130e664b7584e7a5b2cdb90ba4278b55ab1051adf66d5ae872b992107a6a35f414c82c09f0fa99c40f8e6777a12c
+  data.tar.gz: 6753cb134986efe6f0d0dd05235efe5639f948f47896fdd6e555d65c490408da67bb2f184a832dd3b81054edbf80a5e8c7b327d0f0b33ef446b67ba20e52f217

data/lib/predictionio/async_response.rb

@@ -11,9 +11,7 @@ module PredictionIO
     def initialize(request, response = nil)
       @request = request
       @response = Queue.new
-      if response != nil then
-        set(response)
-      end
+      set(response) if response
     end
 
     # Save a Net::HTTPResponse instance to the current instance.

data/lib/predictionio/client.rb

@@ -45,7 +45,7 @@ module PredictionIO
   #
   # == Installation
   # The easiest way is to use RubyGems:
-  #     gem install predictionio-0.6.0.gem
+  #     gem install predictionio
   #
   # == Synopsis
   # The recommended usage of the SDK is to fire asynchronous requests as early as you can in your code,
@@ -53,7 +53,7 @@ module PredictionIO
   #
   # === Instantiate PredictionIO Client
   #     # Include the PredictionIO SDK
-  #     require "PredictionIO"
+  #     require "predictionio"
   #
   #     client = PredictionIO::Client.new(<appkey>)
   #
@@ -124,9 +124,6 @@ module PredictionIO
     # Appkey can be changed on-the-fly after creation of the client.
     attr_accessor :appkey
 
-    # API version can be changed on-the-fly after creation of the client.
-    attr_accessor :apiversion
-
     # Only JSON is currently supported as API response format.
     attr_accessor :apiformat
 
@@ -164,11 +161,10 @@ module PredictionIO
     # - API entry point at http://localhost:8000
     # - API return data format of json
     # - 10 concurrent HTTP(S) connections
-    def initialize(appkey, threads = 10, apiurl = "http://localhost:8000", apiversion = "")
+    def initialize(appkey, threads = 10, apiurl = "http://localhost:8000", thread_timeout = 60)
       @appkey = appkey
-      @apiversion = apiversion
       @apiformat = "json"
-      @http = PredictionIO::Connection.new(URI(apiurl), threads)
+      @http = PredictionIO::Connection.new(URI(apiurl), threads, thread_timeout)
     end
 
     # Returns the number of pending requests within the current client.
@@ -196,11 +192,11 @@ module PredictionIO
       rparams = params
       rparams["pio_appkey"] = @appkey
       rparams["pio_uid"] = uid
-      if params["pio_latitude"] != nil && params["pio_longitude"] != nil then
+      if params["pio_latitude"] && params["pio_longitude"]
         rparams["pio_latlng"] = "#{params["pio_latitude"]},#{params["pio_longitude"]}"
       end
 
-      @http.apost(PredictionIO::AsyncRequest.new(versioned_path("/users.#{@apiformat}"), rparams))
+      @http.apost(PredictionIO::AsyncRequest.new("/users.#{@apiformat}", rparams))
     end
 
     # :category: Synchronous Methods
@@ -213,13 +209,13 @@ module PredictionIO
     # create_user(async_response)
     def create_user(*args)
       uid_or_res = args[0]
-      if uid_or_res.is_a?(PredictionIO::AsyncResponse) then
+      if uid_or_res.is_a?(PredictionIO::AsyncResponse)
         response = uid_or_res.get
       else
         uid = uid_or_res
         response = acreate_user(*args).get
       end
-      unless response.is_a?(Net::HTTPCreated) then
+      unless response.is_a?(Net::HTTPCreated)
         begin
           msg = response.body
         rescue Exception
@@ -240,7 +236,7 @@ module PredictionIO
     #
     # See also #get_user.
     def aget_user(uid)
-      @http.aget(PredictionIO::AsyncRequest.new(versioned_path("/users/#{uid}.#{@apiformat}"),
+      @http.aget(PredictionIO::AsyncRequest.new("/users/#{uid}.#{@apiformat}",
                                                 "pio_appkey" => @appkey,
                                                 "pio_uid" => uid))
     end
@@ -258,14 +254,14 @@ module PredictionIO
     # get_user(uid)
     # get_user(async_response)
     def get_user(uid_or_res)
-      if uid_or_res.is_a?(PredictionIO::AsyncResponse) then
+      if uid_or_res.is_a?(PredictionIO::AsyncResponse)
         response = uid_or_res.get
       else
         response = aget_user(uid_or_res).get
       end
-      if response.is_a?(Net::HTTPOK) then
+      if response.is_a?(Net::HTTPOK)
         res = JSON.parse(response.body)
-        if res["pio_latlng"] != nil then
+        if res["pio_latlng"]
           latlng = res["pio_latlng"]
           res["pio_latitude"] = latlng[0]
           res["pio_longitude"] = latlng[1]
@@ -288,7 +284,7 @@ module PredictionIO
     #
     # See also #delete_user.
     def adelete_user(uid)
-      @http.adelete(PredictionIO::AsyncRequest.new(versioned_path("/users/#{uid}.#{@apiformat}"),
+      @http.adelete(PredictionIO::AsyncRequest.new("/users/#{uid}.#{@apiformat}",
                                                    "pio_appkey" => @appkey,
                                                    "pio_uid" => uid))
     end
@@ -302,12 +298,12 @@ module PredictionIO
     # delete_user(uid)
     # delete_user(async_response)
     def delete_user(uid_or_res)
-      if uid_or_res.is_a?(PredictionIO::AsyncResponse) then
+      if uid_or_res.is_a?(PredictionIO::AsyncResponse)
         response = uid_or_res.get
       else
         response = adelete_user(uid_or_res).get
       end
-      unless response.is_a?(Net::HTTPOK) then
+      unless response.is_a?(Net::HTTPOK)
         begin
           msg = response.body
         rescue Exception
@@ -332,17 +328,13 @@ module PredictionIO
       rescue Exception
         rparams["pio_itypes"] = itypes
       end
-      if params["pio_latitude"] != nil && params["pio_longitude"] != nil then
+      if params["pio_latitude"] && params["pio_longitude"]
         rparams["pio_latlng"] = "#{params["pio_latitude"]},#{params["pio_longitude"]}"
       end
-      if params["pio_startT"] != nil then
-        rparams["pio_startT"] = ((params["pio_startT"].to_r) * 1000).round(0).to_s
-      end
-      if params["pio_endT"] != nil then
-        rparams["pio_endT"] = ((params["pio_endT"].to_r) * 1000).round(0).to_s
-      end
+      rparams["pio_startT"] = ((params["pio_startT"].to_r) * 1000).round(0).to_s if params["pio_startT"]
+      rparams["pio_endT"]   = ((params["pio_endT"].to_r) * 1000).round(0).to_s if params["pio_endT"]
 
-      @http.apost(PredictionIO::AsyncRequest.new(versioned_path("/items.#{@apiformat}"), rparams))
+      @http.apost(PredictionIO::AsyncRequest.new("/items.#{@apiformat}", rparams))
     end
 
     # :category: Synchronous Methods
@@ -355,12 +347,12 @@ module PredictionIO
     # create_item(async_response)
     def create_item(*args)
       iid_or_res = args[0]
-      if iid_or_res.is_a?(PredictionIO::AsyncResponse) then
+      if iid_or_res.is_a?(PredictionIO::AsyncResponse)
         response = iid_or_res.get
       else
         response = acreate_item(*args).get
       end
-      unless response.is_a?(Net::HTTPCreated) then
+      unless response.is_a?(Net::HTTPCreated)
         begin
           msg = response.body
         rescue Exception
@@ -381,7 +373,7 @@ module PredictionIO
     #
     # See also #get_item.
     def aget_item(iid)
-      @http.aget(PredictionIO::AsyncRequest.new(versioned_path("/items/#{iid}.#{@apiformat}"),
+      @http.aget(PredictionIO::AsyncRequest.new("/items/#{iid}.#{@apiformat}",
                                                 "pio_appkey" => @appkey,
                                                 "pio_iid" => iid))
     end
@@ -399,23 +391,23 @@ module PredictionIO
     # get_item(iid)
     # get_item(async_response)
     def get_item(iid_or_res)
-      if iid_or_res.is_a?(PredictionIO::AsyncResponse) then
+      if iid_or_res.is_a?(PredictionIO::AsyncResponse)
         response = iid_or_res.get
       else
         response = aget_item(iid_or_res).get
       end
-      if response.is_a?(Net::HTTPOK) then
+      if response.is_a?(Net::HTTPOK)
         res = JSON.parse(response.body)
-        if res["pio_latlng"] != nil then
+        if res["pio_latlng"]
           latlng = res["pio_latlng"]
           res["pio_latitude"] = latlng[0]
           res["pio_longitude"] = latlng[1]
         end
-        if res["pio_startT"] != nil then
+        if res["pio_startT"]
           startT = Rational(res["pio_startT"], 1000)
           res["pio_startT"] = Time.at(startT)
         end
-        if res["pio_endT"] != nil then
+        if res["pio_endT"]
           endT = Rational(res["pio_endT"], 1000)
           res["pio_endT"] = Time.at(endT)
         end
@@ -437,7 +429,7 @@ module PredictionIO
     #
     # See also #delete_item.
     def adelete_item(iid)
-      @http.adelete(PredictionIO::AsyncRequest.new(versioned_path("/items/#{iid}.#{@apiformat}"),
+      @http.adelete(PredictionIO::AsyncRequest.new("/items/#{iid}.#{@apiformat}",
                                                    "pio_appkey" => @appkey,
                                                    "pio_iid" => iid))
     end
@@ -451,12 +443,12 @@ module PredictionIO
     # delete_item(iid)
     # delete_item(async_response)
     def delete_item(iid_or_res)
-      if iid_or_res.is_a?(PredictionIO::AsyncResponse) then
+      if iid_or_res.is_a?(PredictionIO::AsyncResponse)
         response = iid_or_res.get
       else
         response = adelete_item(iid_or_res).get
       end
-      unless response.is_a?(Net::HTTPOK) then
+      unless response.is_a?(Net::HTTPOK)
         begin
           msg = response.body
         rescue Exception
@@ -482,23 +474,26 @@ module PredictionIO
       rparams["pio_appkey"] = @appkey
       rparams["pio_uid"] = @apiuid
       rparams["pio_n"] = n
-      if params["pio_itypes"] != nil &&
-          params["pio_itypes"].kind_of?(Array) &&
-          params["pio_itypes"].length > 0 then
-        rparams["pio_itypes"] = params["pio_itypes"].join(",")
-      else
-        rparams["pio_itypes"] = params["pio_itypes"]
+      if params["pio_itypes"]
+        if params["pio_itypes"].kind_of?(Array) && params["pio_itypes"].any?
+          rparams["pio_itypes"] = params["pio_itypes"].join(",")
+        else
+          rparams["pio_itypes"] = params["pio_itypes"]
+        end
       end
-      if params["pio_latitude"] != nil && params["pio_longitude"] != nil then
+      if params["pio_latitude"] && params["pio_longitude"]
         rparams["pio_latlng"] = "#{params["pio_latitude"]},#{params["pio_longitude"]}"
       end
-      if params["pio_within"] != nil then
-        rparams["pio_within"] = params["pio_within"]
-      end
-      if params["pio_unit"] != nil then
-        rparams["pio_unit"] = params["pio_unit"]
+      rparams["pio_within"] = params["pio_within"] if params["pio_within"]
+      rparams["pio_unit"] = params["pio_unit"] if params["pio_unit"]
+      if params["pio_attributes"]
+        if params["pio_attributes"].kind_of?(Array) && params["pio_attributes"].any?
+          rparams["pio_attributes"] = params["pio_attributes"].join(",")
+        else
+          rparams["pio_attributes"] = params["pio_attributes"]
+        end
       end
-      @http.aget(PredictionIO::AsyncRequest.new(versioned_path("/engines/itemrec/#{engine}/topn.#{@apiformat}"), rparams))
+      @http.aget(PredictionIO::AsyncRequest.new("/engines/itemrec/#{engine}/topn.#{@apiformat}", rparams))
     end
 
     # :category: Synchronous Methods
@@ -511,14 +506,21 @@ module PredictionIO
     # aget_itemrec_top_n(async_response)
     def get_itemrec_top_n(*args)
       uid_or_res = args[0]
-      if uid_or_res.is_a?(PredictionIO::AsyncResponse) then
-        response = uid_or_res.get
+      if uid_or_res.is_a?(PredictionIO::AsyncResponse)
+        response = uid_or_res
       else
-        response = aget_itemrec_top_n(*args).get
-      end
-      if response.is_a?(Net::HTTPOK) then
-        res = JSON.parse(response.body)
-        res["pio_iids"]
+        response = aget_itemrec_top_n(*args)
+      end
+      http_response = response.get
+      if http_response.is_a?(Net::HTTPOK)
+        res = JSON.parse(http_response.body)
+        if response.request.params.has_key?('pio_attributes')
+          attributes = response.request.params['pio_attributes'].split(',')
+          list_of_attribute_values = attributes.map { |attrib| res[attrib] }
+          res["pio_iids"].zip(*list_of_attribute_values).map { |v| Hash[(['pio_iid'] + attributes).zip(v)] }
+        else
+          res["pio_iids"]
+        end
       else
         begin
           msg = response.body
@@ -540,23 +542,26 @@ module PredictionIO
       rparams["pio_appkey"] = @appkey
       rparams["pio_iid"] = iid
       rparams["pio_n"] = n
-      if params["pio_itypes"] != nil &&
-          params["pio_itypes"].kind_of?(Array) &&
-          params["pio_itypes"].length > 0 then
-        rparams["pio_itypes"] = params["pio_itypes"].join(",")
-      else
-        rparams["pio_itypes"] = params["pio_itypes"]
+      if params["pio_itypes"]
+        if params["pio_itypes"].kind_of?(Array) && params["pio_itypes"].any?
+          rparams["pio_itypes"] = params["pio_itypes"].join(",")
+        else
+          rparams["pio_itypes"] = params["pio_itypes"]
+        end
       end
-      if params["pio_latitude"] != nil && params["pio_longitude"] != nil then
+      if params["pio_latitude"] && params["pio_longitude"]
         rparams["pio_latlng"] = "#{params["pio_latitude"]},#{params["pio_longitude"]}"
       end
-      if params["pio_within"] != nil then
-        rparams["pio_within"] = params["pio_within"]
-      end
-      if params["pio_unit"] != nil then
-        rparams["pio_unit"] = params["pio_unit"]
+      rparams["pio_within"] = params["pio_within"] if params["pio_within"]
+      rparams["pio_unit"] = params["pio_unit"] if params["pio_unit"]
+      if params["pio_attributes"]
+        if params["pio_attributes"].kind_of?(Array) && params["pio_attributes"].any?
+          rparams["pio_attributes"] = params["pio_attributes"].join(",")
+        else
+          rparams["pio_attributes"] = params["pio_attributes"]
+        end
       end
-      @http.aget(PredictionIO::AsyncRequest.new(versioned_path("/engines/itemsim/#{engine}/topn.#{@apiformat}"), rparams))
+      @http.aget(PredictionIO::AsyncRequest.new("/engines/itemsim/#{engine}/topn.#{@apiformat}", rparams))
     end
 
     # :category: Synchronous Methods
@@ -568,15 +573,22 @@ module PredictionIO
     # aget_itemsim_top_n(engine, iid, n, params = {})
     # aget_itemsim_top_n(async_response)
     def get_itemsim_top_n(*args)
-      iid_or_res = args[0]
-      if iid_or_res.is_a?(PredictionIO::AsyncResponse) then
-        response = iid_or_res.get
+      uid_or_res = args[0]
+      if uid_or_res.is_a?(PredictionIO::AsyncResponse)
+        response = uid_or_res
       else
-        response = aget_itemsim_top_n(*args).get
-      end
-      if response.is_a?(Net::HTTPOK) then
-        res = JSON.parse(response.body)
-        res["pio_iids"]
+        response = aget_itemsim_top_n(*args)
+      end
+      http_response = response.get
+      if http_response.is_a?(Net::HTTPOK)
+        res = JSON.parse(http_response.body)
+        if response.request.params.has_key?('pio_attributes')
+          attributes = response.request.params['pio_attributes'].split(',')
+          list_of_attribute_values = attributes.map { |attrib| res[attrib] }
+          res["pio_iids"].zip(*list_of_attribute_values).map { |v| Hash[(['pio_iid'] + attributes).zip(v)] }
+        else
+          res["pio_iids"]
+        end
       else
         begin
           msg = response.body
@@ -599,13 +611,11 @@ module PredictionIO
       rparams["pio_action"] = action
       rparams["pio_uid"] = @apiuid
       rparams["pio_iid"] = iid
-      if params["pio_t"] != nil then
-        rparams["pio_t"] = ((params["pio_t"].to_r) * 1000).round(0).to_s
-      end
-      if params["pio_latitude"] != nil && params["pio_longitude"] != nil then
+      rparams["pio_t"] = ((params["pio_t"].to_r) * 1000).round(0).to_s if params["pio_t"]
+      if params["pio_latitude"] && params["pio_longitude"]
         rparams["pio_latlng"] = "#{params["pio_latitude"]},#{params["pio_longitude"]}"
       end
-      @http.apost(PredictionIO::AsyncRequest.new(versioned_path("/actions/u2i.#{@apiformat}"), rparams))
+      @http.apost(PredictionIO::AsyncRequest.new("/actions/u2i.#{@apiformat}", rparams))
     end
 
     # :category: Synchronous Methods
@@ -614,16 +624,16 @@ module PredictionIO
     # See also #arecord_action_on_item.
     #
     # call-seq:
-    # record_action_on_item(action, uid, iid, params = {})
+    # record_action_on_item(action, iid, params = {})
     # record_action_on_item(async_response)
     def record_action_on_item(*args)
       action_or_res = args[0]
-      if action_or_res.is_a?(PredictionIO::AsyncResponse) then
+      if action_or_res.is_a?(PredictionIO::AsyncResponse)
         response = action_or_res.get
       else
         response = arecord_action_on_item(*args).get
       end
-      unless response.is_a?(Net::HTTPCreated) then
+      unless response.is_a?(Net::HTTPCreated)
         begin
           msg = response.body
         rescue Exception
@@ -632,14 +642,5 @@ module PredictionIO
         raise U2IActionNotCreatedError, msg
       end
     end
-
-    # :nodoc: all
-    private
-
-    def versioned_path(path)
-      # disabled for now
-      # "/#{@apiversion}#{path}"
-      path
-    end
   end
 end

data/lib/predictionio/connection.rb

@@ -14,7 +14,7 @@ module PredictionIO
 
     # Spawns a number of threads with persistent HTTP connection to the specified URI.
     # Sets a default timeout of 5 seconds.
-    def initialize(uri, threads = 1, timeout = 5)
+    def initialize(uri, threads = 1, timeout = 60)
       @packages = Queue.new
       @counter_lock = Mutex.new
       @connections = 0

metadata

@@ -1,24 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: predictionio
 version: !ruby/object:Gem::Version
-  version: 0.6.0
-  prerelease: 
+  version: 0.7.0
 platform: ruby
 authors:
 - The PredictionIO Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-04 00:00:00.000000000 Z
+date: 2014-04-01 00:00:00.000000000 Z
 dependencies: []
-description: ! 'PredictionIO is a prediction server for building smart applications.
-  This gem
-
+description: |
+  PredictionIO is a prediction server for building smart applications. This gem
   provides convenient access of the PredictionIO API to Ruby programmers so that
-
   they can focus on their application logic.
-
-'
 email: support@prediction.io
 executables: []
 extensions: []
@@ -31,26 +26,25 @@ files:
 - lib/predictionio.rb
 homepage: http://prediction.io
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '1.9'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: PredictionIO Ruby SDK
 test_files: []