predictionio-simple 0.9.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2c82647e51feecbf559157484b4b3ebeb3b6f2c1
+  data.tar.gz: 5e08aa77e161a3192d5c33c996866ccba14135d8
+SHA512:
+  metadata.gz: a82d105160bad7f2e4867ae0e2b6a49c00301a71806acf15d02d62f3c78b11c648518db44fcf1d72229769348a14e6eb22f2ff3464cd4f1d156423b7ce7f8049
+  data.tar.gz: f0c4d1e64093e9d0c9bf5169a9266c1f080800c0b1427e2304e3f5cae2091ca638b584a31c2ee6c339cfaf3999e5fc6ffffed93416204d4fcd0516ffaf9403e5

data/lib/predictionio.rb

@@ -0,0 +1,42 @@
+require 'json'
+require 'predictionio/request'
+require 'predictionio/connection'
+require 'predictionio/event_client'
+require 'predictionio/engine_client'
+require 'predictionio/file_exporter'
+require 'predictionio/version'
+
+# The PredictionIO module contains classes that provide convenient access of
+# PredictionIO Event API and Engine Instance over HTTP/HTTPS.
+#
+# To create an app and perform predictions, please download the PredictionIO
+# suite from http://prediction.io.
+#
+# Most functionality is provided by PredictionIO::EventClient and
+# PredictionIO::EngineClient classes.
+#
+# == Deprecation Notice
+#
+# Pre-0.7.x series support is now deprecated. All existing users are strongly
+# encouraged to migrate to 0.8.x.
+#
+# The old Client interface is retained in case of any accidental Gem upgrade.
+# It will be removed in the next minor version.
+#
+# == High-performance Asynchronous Backend
+#
+# All REST request methods come in both synchronous and asynchronous flavors.
+# Both flavors accept the same set of arguments. In addition, all synchronous
+# request methods can instead accept a PredictionIO::AsyncResponse object
+# generated from asynchronous request methods as its first argument. In this
+# case, the method will block until a response is received from it.
+#
+# Any network reconnection and request retry is automatically handled in the
+# background. Exceptions will be thrown after a request times out to avoid
+# infinite blocking.
+#
+# == Installation
+# The easiest way is to use RubyGems:
+#     gem install predictionio
+module PredictionIO
+end

data/lib/predictionio/connection.rb

@@ -0,0 +1,41 @@
+require 'faraday'
+module PredictionIO
+
+  # This class handles Connections
+  class Connection
+
+
+    # Creates a connection to the given URI.
+    def initialize(uri)
+      @connection = Faraday.new(:url => uri) do |faraday|
+        faraday.request  :url_encoded             # form-encode POST params
+        faraday.response :logger                  # log requests to STDOUT
+        faraday.adapter  Faraday.default_adapter  # make requests with Net::HTTP
+      end
+      @connection.headers['Content-Type'] = 'application/json; charset=utf-8'
+    end
+
+    # Create a GET request and return the response.
+    def get(request)
+      @connection.get request.qpath
+    end
+
+    # Create a POST and return the response.
+    def post(request)
+      if request.params.is_a?(Hash)
+        @connection.post request.path, request.params
+      else
+        @connection.post request.path do |req|
+          req.body = request.params
+        end
+      end
+    end
+
+    # Create a DELETE and return the response.
+    def delete(request)
+      @connection.delete request.path do |req|
+        req.body = request.params
+      end
+    end
+  end
+end

data/lib/predictionio/engine_client.rb

@@ -0,0 +1,91 @@
+# Ruby SDK for convenient access of PredictionIO Output API.
+#
+# Author::    PredictionIO Team (support@prediction.io)
+# Copyright:: Copyright (c) 2014 TappingStone, Inc.
+# Copyright:: Copyright (c) 2016 Perpetto BG Ltd.
+# License::   Apache License, Version 2.0
+
+module PredictionIO
+  # This class contains methods that interface with PredictionIO Engine
+  # Instances that are trained from PredictionIO built-in Engines.
+  #
+  # Many REST request methods support optional arguments. They can be supplied
+  # to these methods as Hash'es. For a complete reference, please visit
+  # http://prediction.io.
+  #
+  # == Synopsis
+  # In most cases, using synchronous methods. If you have a special performance
+  # requirement, you may want to take a look at asynchronous methods.
+  #
+  # === Instantiate an EngineClient
+  #     # Include the PredictionIO SDK
+  #     require 'predictionio'
+  #
+  #     client = PredictionIO::EngineClient.new
+  #
+  # === Send a Query to Retrieve Predictions
+  #     # PredictionIO call to record the view action
+  #     begin
+  #       result = client.query('uid' => 'foobar')
+  #     rescue NotFoundError => e
+  #       ...
+  #     rescue BadRequestError => e
+  #       ...
+  #     rescue ServerError => e
+  #       ...
+  #     end
+  class EngineClient
+    # Raised when an event is not created after a synchronous API call.
+    class NotFoundError < StandardError; end
+
+    # Raised when the query is malformed.
+    class BadRequestError < StandardError; end
+
+    # Raised when the Engine Instance returns a server error.
+    class ServerError < StandardError; end
+
+    # Create a new PredictionIO Event Client with defaults:
+    # - 1 concurrent HTTP(S) connections (threads)
+    # - API entry point at http://localhost:8000 (apiurl)
+    # - a 60-second timeout for each HTTP(S) connection (thread_timeout)
+    def initialize(apiurl = 'http://localhost:8000')
+      @http = PredictionIO::Connection.new(URI(apiurl))
+    end
+
+
+    # Returns PredictionIO's status in string.
+    def get_status
+      status = @http.get(PredictionIO::Request.new('/'))
+      begin
+        status.body
+      rescue
+        status
+      end
+    end
+
+    # Sends a query and returns the response.
+    # The query should be a Ruby data structure that can be
+    # converted to a JSON object.
+    #
+    # Corresponding REST API method: POST /
+    def send_query(query)
+      response = @http.post(PredictionIO::Request.new('/queries.json', query.to_json))
+      return JSON.parse(response.body) if response.success?
+      begin
+        msg = response.body
+      rescue
+        raise response
+      end
+      case response.status
+      when 400
+        fail BadRequestError, msg
+      when 404
+        fail NotFoundError, msg
+      when 500
+        fail ServerError, msg
+      else
+        fail msg
+      end
+    end
+  end
+end

data/lib/predictionio/event_client.rb

@@ -0,0 +1,178 @@
+# Ruby SDK for convenient access of PredictionIO Output API.
+#
+# Author::    PredictionIO Team (support@prediction.io)
+# Copyright:: Copyright (c) 2014 TappingStone, Inc.
+# Copyright:: Copyright (c) 2016 Perpetto BG Ltd.
+# License::   Apache License, Version 2.0
+
+require 'date'
+require "net/http"
+
+module PredictionIO
+  # This class contains methods that interface with the PredictionIO Event
+  # Server via the PredictionIO Event API using REST requests.
+  #
+  # Many REST request methods support optional arguments. They can be supplied
+  # to these methods as Hash'es. For a complete reference, please visit
+  # http://prediction.io.
+  #
+  # == High-performance Asynchronous Backend
+  #
+  # All REST request methods come in both synchronous and asynchronous flavors.
+  # Both flavors accept the same set of arguments. In addition, all synchronous
+  # request methods can instead accept a PredictionIO::AsyncResponse object
+  # generated from asynchronous request methods as its first argument. In this
+  # case, the method will block until a response is received from it.
+  #
+  # Any network reconnection and request retry is automatically handled in the
+  # background. Exceptions will be thrown after a request times out to avoid
+  # infinite blocking.
+  #
+  # == Installation
+  # The easiest way is to use RubyGems:
+  #     gem install predictionio
+  #
+  # == Synopsis
+  # In most cases, using synchronous methods. If you have a special performance
+  # requirement, you may want to take a look at asynchronous methods.
+  #
+  # === Instantiate an EventClient
+  #     # Include the PredictionIO SDK
+  #     require 'predictionio'
+  #
+  #     client = PredictionIO::EventClient.new(<access_key>)
+  #
+  # === Import a User Record from Your App (with asynchronous/non-blocking
+  #     requests)
+  #
+  #     #
+  #     # (your user registration logic)
+  #     #
+  #
+  #     uid = get_user_from_your_db()
+  #
+  #     # PredictionIO call to create user
+  #     response = client.aset_user(uid)
+  #
+  #     #
+  #     # (other work to do for the rest of the page)
+  #     #
+  #
+  #     begin
+  #       # PredictionIO call to retrieve results from an asynchronous response
+  #       result = client.set_user(response)
+  #     rescue PredictionIO::EventClient::NotCreatedError => e
+  #       log_and_email_error(...)
+  #     end
+  #
+  # === Import a User Action (Rate) from Your App (with synchronous/blocking
+  #     requests)
+  #     # PredictionIO call to record the view action
+  #     begin
+  #       result = client.record_user_action_on_item('rate', 'foouser',
+  #                                                  'baritem',
+  #                                                  'rating' => 4)
+  #     rescue PredictionIO::EventClient::NotCreatedError => e
+  #       ...
+  #     end
+  class EventClient
+    # Raised when an event is not created after a synchronous API call.
+    class NotCreatedError < StandardError; end
+
+    # Create a new PredictionIO Event Client with defaults:
+    # - 1 concurrent HTTP(S) connections (threads)
+    # - API entry point at http://localhost:7070 (apiurl)
+    # - a 60-second timeout for each HTTP(S) connection (thread_timeout)
+    def initialize(access_key, apiurl = 'http://localhost:7070')
+      @access_key = access_key
+      @http = PredictionIO::Connection.new(URI(apiurl))
+    end
+
+    # Returns PredictionIO's status in string.
+    def get_status
+      status = @http.get(PredictionIO::Request.new('/'))
+      begin
+        status.body
+      rescue
+        status
+      end
+    end
+
+    # Request to create an event and return the response.
+    #
+    # Corresponding REST API method: POST /events.json
+    def create_event(event, entity_type, entity_id, optional = {})
+      h = optional
+      h.key?('eventTime') || h['eventTime'] = DateTime.now.to_s
+      h['event'] = event
+      h['entityType'] = entity_type
+      h['entityId'] = entity_id
+      @http.post(PredictionIO::Request.new(
+        "/events.json?accessKey=#{@access_key}", h.to_json
+      ))
+    end
+
+    # Request to set properties of a user and return the response.
+    #
+    # Corresponding REST API method: POST /events.json
+    def set_user(uid, optional = {})
+      create_event('$set', 'user', uid, optional)
+    end
+
+    # Request to unset properties of a user and return the response.
+    #
+    # properties must be a non-empty Hash.
+    #
+    # Corresponding REST API method: POST /events.json
+    def unset_user(uid, optional)
+      optional.key?('properties') ||
+        fail(ArgumentError, 'properties must be present when event is $unset')
+      optional['properties'].empty? &&
+        fail(ArgumentError, 'properties cannot be empty when event is $unset')
+      create_event('$unset', 'user', uid, optional)
+    end
+
+    # Request to delete a user and return the response.
+    #
+    # Corresponding REST API method: POST /events.json
+    def delete_user(uid)
+      create_event('$delete', 'user', uid)
+    end
+
+    # Request to set properties of an item and return the response.
+    #
+    # Corresponding REST API method: POST /events.json
+    def set_item(iid, optional = {})
+      create_event('$set', 'item', iid, optional)
+    end
+
+    # Request to unset properties of an item and return the response.
+    #
+    # properties must be a non-empty Hash.
+    #
+    # Corresponding REST API method: POST /events.json
+    def unset_item(iid, optional)
+      optional.key?('properties') ||
+        fail(ArgumentError, 'properties must be present when event is $unset')
+      optional['properties'].empty? &&
+        fail(ArgumentError, 'properties cannot be empty when event is $unset')
+      create_event('$unset', 'item', iid, optional)
+    end
+
+    # Request to delete an item and return the response.
+    #
+    # Corresponding REST API method: POST /events.json
+    def delete_item(uid)
+      create_event('$delete', 'item', uid)
+    end
+
+    # Request to record an action on an item and return the response.
+    #
+    # Corresponding REST API method: POST /events.json
+    def record_user_action_on_item(action, uid, iid, optional = {})
+      optional['targetEntityType'] = 'item'
+      optional['targetEntityId'] = iid
+      create_event(action, 'user', uid, optional)
+    end
+  end
+end

data/lib/predictionio/file_exporter.rb

@@ -0,0 +1,29 @@
+module PredictionIO
+  # This class contains methods that allow you to export data for import though:
+  #
+  # $ pio import FILENAME
+
+  class FileExporter
+
+    def initialize(filename)
+      @filename = filename
+      @file = File.open(@filename, 'w')
+    end
+
+    def create_event(event, entity_type, entity_id, optional = {})
+
+      h = optional
+      h.key?('eventTime') || h['eventTime'] = DateTime.now.to_s
+      h['event'] = event
+      h['entityType'] = entity_type
+      h['entityId'] = entity_id
+
+      json = h.to_json
+      @file.write("#{json}\n")
+    end
+
+    def close
+      @file.close
+    end
+  end
+end

data/lib/predictionio/request.rb

@@ -0,0 +1,24 @@
+module PredictionIO
+  # This class contains the URI path and query parameters that is consumed by
+  # PredictionIO::Connection for asynchronous HTTP requests.
+  class Request
+
+    # The path portion of the request URI.
+    attr_reader :path
+
+    # Query parameters, or form data.
+    attr_reader :params
+
+    # Populates the package with request URI path, and optionally query
+    # parameters or form data.
+    def initialize(path, params = {})
+      @params = params
+      @path = path
+    end
+
+    # Returns an URI path with query parameters encoded for HTTP GET requests.
+    def qpath
+      "#{@path}?#{URI::encode_www_form(@params)}"
+    end
+  end
+end

data/lib/predictionio/version.rb

@@ -0,0 +1,3 @@
+module PredictionIO
+  VERSION = '0.9.6'
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: predictionio-simple
+version: !ruby/object:Gem::Version
+  version: 0.9.6
+platform: ruby
+authors:
+- Yavor Stoychev
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-11-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+description: |
+  PredictionIO is an open source machine learning server for developers and data
+  scientists to create predictive engines for production environments. This gem
+  provides convenient access to the PredictionIO API for Ruby programmers so that
+  you can focus on application logic.
+email: stoychev.yavor@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/predictionio.rb
+- lib/predictionio/connection.rb
+- lib/predictionio/engine_client.rb
+- lib/predictionio/event_client.rb
+- lib/predictionio/file_exporter.rb
+- lib/predictionio/request.rb
+- lib/predictionio/version.rb
+homepage: https://github.com/voran/incubator-predictionio-sdk-ruby-simple
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: PredictionIO Ruby SDK Simplified
+test_files: []