lumidatum_client 0.1.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7f9eb2eee7f3432b6c5628a87aead931b889382d
+  data.tar.gz: 699fe1ea088c18ac0db067d3e27d9fdd2cbd48d9
+SHA512:
+  metadata.gz: ed2ffeb4a32e92a1498fb6caf1b670a0100a6a7b9c0dd5cff1dc770b75cc428441434468045086f56802abdc7087bca174a211fc9e9af47c4e05c00a8f90eb63
+  data.tar.gz: f9523e0ec6bbbf958dc009cb2555f4b900a7e86506456287a5029c45215e5347edce721d8bd37d2ca122b5063c95d6a763a20eb9042ac5a05ceca2e15208585b

data/lib/lumidatum_client.rb

@@ -0,0 +1,195 @@
+require "json"
+
+require "httpclient"
+
+
+class LumidatumClient
+  attr_accessor :authentication_token
+  attr_accessor :model_id
+  attr_accessor :host_address
+  attr_accessor :http_client
+  attr_accessor :file_handler
+
+  def initialize(authentication_token, model_id=nil, host_address="https://www.lumidatum.com", http_client=nil, file_handler=File)
+    if authentication_token == nil
+      raise ArgumentError, "authentication_token must not be nil"
+    end
+
+    @authentication_token = authentication_token
+    @model_id = model_id
+    @host_address = host_address.chomp("/")
+
+    if http_client == nil
+      @http_client = HTTPClient.new
+    else
+      @http_client = http_client;
+    end
+
+    @file_handler = file_handler
+  end
+
+
+  def getItemRecommendations(parameters, model_id: nil, deserialize_response: true)
+    model_id = _getModelIdOrError(model_id)
+
+    return api("POST", "api/predict/#{model_id}", nil, parameters, deserialize_response: deserialize_response)
+  end
+
+  def getUserRecommendations(parameters, model_id: nil, deserialize_response: true)
+    model_id = _getModelIdOrError(model_id)
+
+    return api("POST", "api/predict/#{model_id}", nil, parameters, deserialize_response: deserialize_response)
+  end
+
+
+  # Data upload
+  def sendUserData(data_string: nil, file_path: nil, model_id: nil)
+    model_id = _getModelIdOrError(model_id)
+
+    return sendData("users", data_string, file_path, model_id)
+  end
+
+  def sendItemData(data_string: nil, file_path: nil, model_id: nil)
+    model_id = _getModelIdOrError(model_id)
+
+    return sendData("items", data_string, file_path, model_id)
+  end
+
+  def sendTransactionData(data_string: nil, file_path: nil, model_id: nil)
+    model_id = _getModelIdOrError(model_id)
+
+    return sendData("transactions", data_string, file_path, model_id)
+  end
+
+  def sendData(data_type, data_string, file_path, model_id)
+    model_id = _getModelIdOrError(model_id)
+
+    url_endpoint = "api/data"
+
+    if data_string != nil
+      url_query_parameters = {:model_id => model_id, :data_type => data_type}
+
+      return api("POST", url_endpoint, url_query_parameters, parameters)
+    else
+      file_name = File.basename(file_path)
+      file_size = nil
+      presigned_response_object = getPresignedResponse(
+        nil,
+        model_id,
+        data_type: data_type,
+        file_name: file_name,
+        file_size: file_size
+      )
+    end
+
+    @file_handler.open(file_path) do |upload_file|
+      form_fields = presigned_response_object["fields"]
+      form_fields["file"] = upload_file
+
+      return @http_client.post(presigned_response_object["url"], form_fields)
+    end
+  end
+
+  # File download
+  def getLatestLTVReport(download_file_path, model_id: nil, zipped: true, stream_download: true)
+    model_id = _getModelIdOrError(model_id)
+
+    latest_key_name = getAvailableReports("LTV", model_id, zipped: zipped)
+
+    presigned_response_object = getPresignedResponse(latest_key_name, model_id, is_download: true)
+
+    report_response = @http_client.get(presigned_response_object["url"])
+    open(download_file_path, "wb") do |file|
+      file.write(report_response.body)
+    end
+
+    return report_response
+  end
+
+  def getLatestSegmentationReport(download_file_path, model_id: nil, zipped: true, stream_download: true)
+    model_id = _getModelIdOrError(model_id)
+
+    latest_key_name = getAvailableReports("SEG", model_id, zipped: zipped)
+    presigned_response_object = getPresignedResponse(latest_key_name, model_id, is_download: true)
+
+    report_response = @http_client.get(presigned_response_object["url"])
+    open(download_file_path, "wb") do |file|
+      file.write(report_response.body)
+    end
+
+    return report_response
+  end
+
+  def getAvailableReports(report_type, model_id, zipped: true, latest: true)
+    url_query_parameters = {:model_id => model_id, :report_type => report_type, :zipped => zipped, :latest => true}
+    list_reports_response = api("GET", "api/data", url_query_parameters, model_id, deserialize_response: false)
+    list_reports_response_object = JSON.parse(list_reports_response.body)
+
+    if list_reports_response.status != 200
+      raise IOError, "HTTP #{list_reports_response.status}: #{list_reports_response_object["error"]} "
+    end
+
+    if list_reports_response_object["latest_key_name"] != nil
+
+      return list_reports_response_object["latest_key_name"]
+    else
+
+      return list_reports_response_object["available_key_names"]
+    end
+  end
+
+  def getPresignedResponse(key_name, model_id, data_type: nil, file_name: nil, file_size: nil, is_download: false)
+    parameters = {"model_id": model_id}
+
+    if is_download
+      parameters["key_name"] = key_name
+      parameters["is_download"] = true
+    else
+      parameters["data_type"] = data_type
+      parameters["file_name"] = file_name
+      parameters["file_size"] = file_size
+      parameters["presigned_url_http_method"] = "PUT"
+    end
+
+    return api("POST", "api/data", nil, parameters)
+  end
+
+
+  def api(http_method, url_endpoint, url_query_parameters, parameters, deserialize_response: true)
+    formatted_url = "#{@host_address}/#{url_endpoint}"
+    if url_query_parameters
+      formatted_url = formatted_url + "?" + URI.encode_www_form(url_query_parameters)
+    end
+
+    headers = {"authorization" => @authentication_token, "content-type" => "application/json"}
+
+    if http_method == "GET"
+      api_response = @http_client.get(formatted_url, header: headers)
+    elsif http_method == "POST"
+      if parameters.class != String
+        parameters_str = JSON.generate(parameters)
+      end
+      api_response = @http_client.post(formatted_url, header: headers, body: parameters_str)
+    end
+
+    if deserialize_response
+      if api_response.status == 200 or api_response.status == 201
+
+        return JSON.parse(api_response.body)
+      end
+    else
+
+      return api_response
+    end
+  end
+
+
+  def _getModelIdOrError(model_id)
+    model_id = if model_id == nil then @model_id else model_id end
+    if model_id == nil
+      raise ArgumentError, "model_id must be set during client instantiation or provided during your instance method call."
+    end
+
+    return model_id
+  end
+end

data/tests/test_client_unit_tests.rb

@@ -0,0 +1,181 @@
+require "json"
+require "minitest/autorun"
+
+require "webmock/test_unit"
+
+require "./lib/lumidatum_client.rb"
+
+
+class ClientInit < Minitest::Test
+  def setup
+    @valid_api_token = "Token <API key>"
+    @valid_model_id = 123
+    @custom_host_address = "http://localhost:8000"
+
+    @default_host_address = "https://www.lumidatum.com"
+  end
+
+  # No specified host/default host
+  def test_client_init
+    test_client = LumidatumClient.new(@valid_api_token, @valid_model_id, @custom_host_address)
+
+    assert_instance_of(LumidatumClient, test_client)
+  end
+
+  def test_default_host
+    test_client = LumidatumClient.new(@valid_api_token, @valid_model_id)
+
+    # Default host should be https://www.lumidatum.com
+    assert_equal(@default_host_address, test_client.host_address)
+  end
+
+  def test_specifying_a_host
+    test_client = LumidatumClient.new(@valid_api_token, @valid_model_id, @custom_host_address)
+
+    assert_equal(@custom_host_address, test_client.host_address)
+  end
+
+  def test_nil_model_id_is_fine
+    test_client = LumidatumClient.new(@valid_api_token)
+
+    assert_nil(test_client.model_id)
+  end
+
+  def test_nil_api_token_error
+    assert_raises ArgumentError do
+      LumidatumClient.new(nil, @valid_model_id)
+    end
+  end
+end
+
+
+def createTestClient
+
+  return LumidatumClient.new("API Key", 123)
+end
+
+def createTestClientNoModelId
+
+  return LumidatumClient.new("API Key")
+end
+
+
+class Personalization
+  def setup
+    @test_client = createTestClient
+  end
+
+  def test_item_recs
+    test_recommendations = [[], [], []]
+    WebMock.stub_request(
+      :post,
+      "https://www.lumidatum.com/api/predict/123"
+    ).to_return(
+      status: 200,
+      body: JSON.generate(test_recommendations)
+    )
+
+    recommendations = @test_client.getItemRecommendations({})
+
+    assert_equal(test_recommendations, recommendations)
+  end
+end
+
+
+def setupValidUploadResponses
+  # Upload presign request
+  WebMock.stub_request(
+    :post,
+    "https://www.lumidatum.com/api/data"
+  ).to_return(
+    status: 201,
+    body: JSON.generate({"url" => "http://test.upload.url", "fields" => {}})
+  )
+  # S3 upload response
+  WebMock.stub_request(
+    :post,
+    "http://test.upload.url"
+  ).to_return(
+    status: 204
+  )
+end
+
+
+class UploadDataFiles < Minitest::Test
+  def setup
+    @test_client = createTestClient
+  end
+
+  def test_sending_file
+    setupValidUploadResponses
+
+    file_upload_response = @test_client.sendTransactionData(file_path: "tests/resources/test_data.csv")
+
+    assert_equal(204, file_upload_response.status)
+  end
+
+  def test_no_model_id_error
+    no_model_id_test_client = createTestClientNoModelId
+
+    assert_raises ArgumentError do
+      no_model_id_test_client.sendTransactionData(file_path: "tests/resources/test_data.csv")
+    end
+  end
+
+  def test_no_model_id_in_client
+    setupValidUploadResponses
+
+    no_model_id_test_client = createTestClientNoModelId
+
+    no_model_id_test_client.sendTransactionData(file_path: "tests/resources/test_data.csv", model_id: 123)
+  end
+end
+
+class DownloadReports < Minitest::Test
+  def setup
+    @test_client = createTestClient
+  end
+
+  def test_no_report_yet
+    # List response
+    WebMock.stub_request(
+      :get,
+      "https://www.lumidatum.com/api/data?latest=true&model_id=123&report_type=LTV&zipped=true&latest=true"
+    ).to_return(
+      status: 404,
+      body: JSON.generate({"error" => "Requested item does not exist."})
+    )
+
+    # Raises error for 404 response on list call
+    assert_raises IOError do
+      file_download_response = @test_client.getLatestLTVReport("test_download_file.csv")
+    end
+  end
+
+  def test_getting_report
+    # List response
+    WebMock.stub_request(
+      :get,
+      "https://www.lumidatum.com/api/data?latest=true&model_id=123&report_type=LTV&zipped=true&latest=true"
+    ).to_return(
+      status: 200,
+      body: JSON.generate({"key_name" => "test_key_name"})
+    )
+    # Presign response
+    WebMock.stub_request(
+      :post, "https://www.lumidatum.com/api/data"
+    ).to_return(
+      status: 200,
+      body: JSON.generate({"url" => "http://test.download.url"})
+    )
+    # S3 download response
+    WebMock.stub_request(:get, "http://test.download.url")
+
+    file_download_response = @test_client.getLatestLTVReport("test_download_file.csv")
+
+    assert_equal(200, file_download_response.status)
+
+    # Clean up
+    File.delete("test_download_file.csv")
+  end
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: lumidatum_client
+version: !ruby/object:Gem::Version
+  version: 0.1.4
+platform: ruby
+authors:
+- Mat Lee
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-03-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httpclient
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+description: ''
+email:
+- matt@lumidatum.com
+executables:
+- lumidatum_client
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/lumidatum_client
+- lib/lumidatum_client.rb
+- tests/test_client_unit_tests.rb
+homepage: https://www.lumidatum.com
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.10
+signing_key: 
+specification_version: 4
+summary: ''
+test_files:
+- tests/test_client_unit_tests.rb