ibm_watson 0.1.0

data/lib/ibm_watson/watson_api_exception.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require("json")
+# Custom exception class for errors returned from Watson APIs
+class WatsonApiException < StandardError
+  attr_reader :code, :error, :info, :transaction_id, :global_transaction_id
+  # :param HTTP::Response response: The response object from the Watson API
+  def initialize(code: nil, error: nil, info: nil, transaction_id: nil, global_transaction_id: nil, response: nil)
+    if code.nil? || error.nil?
+      @code = response.code
+      @error = response.reason
+      unless response.body.empty?
+        body_hash = JSON.parse(response.body.to_s)
+        @code = body_hash["code"] || body_hash["error_code"]
+        @error = body_hash["error"] || body_hash["error_message"]
+        %w[code error_code error error_message].each { |k| body_hash.delete(k) }
+        @info = body_hash
+      end
+      @transaction_id = transaction_id
+      @global_transaction_id = global_transaction_id
+      @transaction_id = response.headers["X-DP-Watson-Tran-ID"] if response.headers.include?("X-DP-Watson-Tran-ID")
+      @global_transaction_id = response.headers["X-Global-Transaction-ID"] if response.headers.include?("X-Global-Transaction-ID")
+    else
+      # :nocov:
+      @code = code
+      @error = error
+      @info = info
+      @transaction_id = transaction_id
+      @global_transaction_id = global_transaction_id
+      # :nocov:
+    end
+  end
+
+  def to_s
+    msg = "Error: #{@error}, Code: #{@code}"
+    msg += ", Information: #{@info}" unless @info.nil?
+    msg += ", X-dp-watson-tran-id: #{@transaction_id}" unless @transaction_id.nil?
+    msg += ", X-global-transaction-id: #{@global_transaction_id}" unless @global_transaction_id.nil?
+    msg
+  end
+end

data/lib/ibm_watson/watson_service.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require("http")
+require("rbconfig")
+require("stringio")
+require("json")
+require_relative("./detailed_response.rb")
+require_relative("./watson_api_exception.rb")
+require_relative("./iam_token_manager.rb")
+require_relative("./version.rb")
+# require("httplog")
+# HttpLog.configure do |config|
+#   config.log_connect   = true
+#   config.log_request   = true
+#   config.log_headers   = true
+#   config.log_data      = true
+#   config.log_status    = true
+#   config.log_response  = true
+# end
+
+# Class for interacting with the Watson API
+class WatsonService
+  attr_accessor :password, :url, :username
+  attr_reader :conn
+  def initialize(vars)
+    defaults = {
+      vcap_services_name: nil,
+      username: nil,
+      password: nil,
+      use_vcap_services: true,
+      api_key: nil,
+      x_watson_learning_opt_out: false,
+      iam_api_key: nil,
+      iam_access_token: nil,
+      iam_url: nil
+    }
+    vars = defaults.merge(vars)
+    @url = vars[:url]
+    @username = nil
+    @password = nil
+    @token_manager = nil
+    @temp_headers = nil
+
+    user_agent_string = "watson-apis-ruby-sdk-" + IBMWatson::VERSION
+    user_agent_string += " #{RbConfig::CONFIG["host"]}"
+    user_agent_string += " #{RbConfig::CONFIG["RUBY_BASE_NAME"]}-#{RbConfig::CONFIG["RUBY_PROGRAM_VERSION"]}"
+
+    headers = {
+      "User-Agent" => user_agent_string
+    }
+    headers["x-watson-learning-opt-out"] = true if vars[:x_watson_learning_opt_out]
+    if vars[:use_vcap_services]
+      @vcap_service_credentials = load_from_vcap_services(service_name: vars[:vcap_services_name])
+      if !@vcap_service_credentials.nil? && @vcap_service_credentials.instance_of?(Hash)
+        @url = @vcap_service_credentials["url"]
+        @username = @vcap_service_credentials["username"] if @vcap_service_credentials.key?("username")
+        @password = @vcap_service_credentials["password"] if @vcap_service_credentials.key?("password")
+        @iam_api_key = @vcap_service_credentials["iam_api_key"] if @vcap_service_credentials.key?("iam_api_key")
+        @iam_access_token = @vcap_service_credentials["iam_access_token"] if @vcap_service_credentials.key?("iam_access_token")
+        @iam_url = @vcap_service_credentials["iam_url"] if @vcap_service_credentials.key?("iam_url")
+      end
+    end
+
+    if !vars[:iam_access_token].nil? || !vars[:iam_api_key].nil?
+      _token_manager(iam_api_key: vars[:iam_api_key], iam_access_token: vars[:iam_access_token], iam_url: vars[:iam_url])
+    elsif !vars[:username].nil? && !vars[:password].nil?
+      if vars[:username] == "apikey"
+        _iam_api_key(iam_api_key: vars[:password])
+      else
+        @username = vars[:username]
+        @password = vars[:password]
+      end
+    end
+
+    @conn = HTTP::Client.new(
+      headers: headers
+    ).timeout(
+      :per_operation,
+      read: 60,
+      write: 60,
+      connect: 60
+    )
+  end
+
+  def load_from_vcap_services(service_name:)
+    vcap_services = ENV["VCAP_SERVICES"]
+    unless vcap_services.nil?
+      services = JSON.parse(vcap_services)
+      return services[service_name][0]["credentials"] if services.key?(service_name)
+    end
+    nil
+  end
+
+  def add_default_headers(headers: {})
+    raise TypeError unless headers.instance_of?(Hash)
+    headers.each_pair { |k, v| @conn.default_options.headers.add(k, v) }
+  end
+
+  def _token_manager(iam_api_key: nil, iam_access_token: nil, iam_url: nil)
+    @iam_api_key = iam_api_key
+    @iam_access_token = iam_access_token
+    @iam_url = iam_url
+    @token_manager = IAMTokenManager.new(iam_api_key: iam_api_key, iam_access_token: iam_access_token, iam_url: iam_url)
+  end
+
+  def _iam_access_token(iam_access_token:)
+    @token_manager._access_token(iam_access_token: iam_access_token) unless @token_manager.nil?
+    @token_manager = IAMTokenManager.new(iam_access_token: iam_access_token) if @token_manager.nil?
+    @iam_access_token = iam_access_token
+  end
+
+  def _iam_api_key(iam_api_key:)
+    @token_manager._iam_api_key(iam_api_key: iam_api_key) unless @token_manager.nil?
+    @token_manager = IAMTokenManager.new(iam_api_key: iam_api_key) if @token_manager.nil?
+    @iam_api_key = iam_api_key
+  end
+
+  # @return [DetailedResponse]
+  def request(args)
+    defaults = { method: nil, url: nil, accept_json: false, headers: nil, params: nil, json: {}, data: nil }
+    args = defaults.merge(args)
+    args[:data].delete_if { |_k, v| v.nil? } if args[:data].instance_of?(Hash)
+    args[:json] = args[:data].merge(args[:json]) if args[:data].respond_to?(:merge)
+    args[:json] = args[:data] if args[:json].empty? || (args[:data].instance_of?(String) && !args[:data].empty?)
+    args[:json].delete_if { |_k, v| v.nil? } if args[:json].instance_of?(Hash)
+    args[:headers]["Accept"] = "application/json" if args[:accept_json]
+    args[:headers]["Content-Type"] = "application/json" unless args[:headers].key?("Content-Type")
+    args[:json] = args[:json].to_json if args[:json].instance_of?(Hash)
+    args[:headers].delete_if { |_k, v| v.nil? } if args[:headers].instance_of?(Hash)
+    args[:params].delete_if { |_k, v| v.nil? } if args[:params].instance_of?(Hash)
+    args[:form].delete_if { |_k, v| v.nil? } if args.key?(:form)
+    args.delete_if { |_, v| v.nil? }
+    args[:headers].delete("Content-Type") if args.key?(:form) || args[:json].nil?
+
+    if @username == "apikey"
+      _iam_api_key(iam_api_key: @password)
+      @username = nil
+    end
+
+    conn = @conn
+    if !@token_manager.nil?
+      access_token = @token_manager._token
+      args[:headers]["Authorization"] = "Bearer #{access_token}"
+    elsif !@username.nil? && !@password.nil?
+      conn = @conn.basic_auth(user: @username, pass: @password)
+    end
+
+    args[:headers] = args[:headers].merge(@temp_headers) unless @temp_headers.nil?
+    @temp_headers = nil unless @temp_headers.nil?
+
+    if args.key?(:form)
+      response = conn.follow.request(
+        args[:method],
+        HTTP::URI.parse(@url + args[:url]),
+        headers: conn.default_options.headers.merge(HTTP::Headers.coerce(args[:headers])),
+        params: args[:params],
+        form: args[:form]
+      )
+    else
+      response = conn.follow.request(
+        args[:method],
+        HTTP::URI.parse(@url + args[:url]),
+        headers: conn.default_options.headers.merge(HTTP::Headers.coerce(args[:headers])),
+        body: args[:json],
+        params: args[:params]
+      )
+    end
+    return DetailedResponse.new(response: response) if (200..299).cover?(response.code)
+    raise WatsonApiException.new(response: response)
+  end
+
+  # @note Chainable
+  # @param headers [Hash] Custom headers to be sent with the request
+  # @return [self]
+  def headers(headers)
+    raise TypeError("Expected Hash type, received #{headers.class}") unless headers.instance_of?(Hash)
+    @temp_headers = headers
+    self
+  end
+end

data/lib/ibm_watson/websocket/recognize_callback.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module IBMWatson
+  # Abstract class for Recognize Callbacks
+  class RecognizeCallback
+    def initialize(*); end
+
+    # Called when an interim result is received
+    def on_transcription(transcript:); end
+
+    # Called when a WebSocket connection is made
+    def on_connected; end
+
+    # Called when there is an error in the WebSocket connection
+    def on_error(error:); end
+
+    # Called when there is an inactivity timeout
+    def on_inactivity_timeout(error:); end
+
+    # Called when the service is listening for audio
+    def on_listening; end
+
+    # Called after the service returns the final result for the transcription
+    def on_transcription_complete; end
+
+    # Called when the service returns the final hypothesis
+    def on_hypothesis(hypothesis:); end
+
+    # Called when the service returns results. The data is returned unparsed
+    def on_data(data:); end
+  end
+end

data/lib/ibm_watson/websocket/speech_to_text_websocket_listener.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require("eventmachine")
+require("faye/websocket")
+require("json")
+
+ONE_KB = 1024
+TIMEOUT_PREFIX = "No speech detected for".freeze
+CLOSE_SIGNAL = 1000
+TEN_MILLISECONDS = 0.01
+
+# Class for interacting with the WebSocket API
+class WebSocketClient
+  def initialize(audio: nil, chunk_data:, options:, recognize_callback:, url:, headers:)
+    @audio = audio
+    @options = options
+    @callback = recognize_callback
+    @bytes_sent = 0
+    @headers = headers
+    @is_listening = false
+    @url = url
+    @timer = nil
+    @chunk_data = chunk_data
+    @mic_running = false
+    @data_size = audio.nil? ? 0 : @audio.size
+    @queue = Queue.new
+  end
+
+  def start
+    on_open = lambda do |event|
+      on_connect(event)
+      @client.send(build_start_message(options: @options))
+      @mic_running = true if @chunk_data
+      send_audio(data: @audio)
+    end
+
+    on_message = lambda do |event|
+      json_object = JSON.parse(event.data)
+      if json_object.key?("error")
+        error = json_object["error"]
+        if error.start_with?(TIMEOUT_PREFIX)
+          @callback.on_inactivity_timeout(error: error)
+        else
+          @callback.on_error(error: error)
+        end
+      elsif json_object.key?("state")
+        if !@is_listening
+          @is_listening = true
+        else
+          @client.send(build_close_message)
+          @callback.on_transcription_complete
+          @client.close(CLOSE_SIGNAL)
+        end
+      elsif json_object.key?("results") || json_object.key?("speaker_labels")
+        hypothesis = ""
+        unless json_object["results"].nil?
+          hypothesis = json_object.dig("results", 0, "alternatives", 0, "transcript")
+          b_final = json_object.dig("results", 0, "final")
+          transcripts = extract_transcripts(alternatives: json_object.dig("results", 0, "alternatives"))
+
+          @callback.on_hypothesis(hypothesis: hypothesis) if b_final
+
+          @callback.on_transcription(transcript: transcripts)
+          @callback.on_data(data: json_object)
+        end
+      end
+    end
+
+    on_close = lambda do |_event|
+      @client = nil
+      EM.stop_event_loop
+    end
+
+    on_error = lambda do |event|
+      p event.message
+    end
+
+    EM.reactor_thread.join unless EM.reactor_thread.nil?
+    EM.run do
+      @client = Faye::WebSocket::Client.new(@url, nil, headers: @headers)
+      @client.onclose = on_close
+      @client.onerror = on_error
+      @client.onmessage = on_message
+      @client.onopen = on_open
+      @client.add_listener(Faye::WebSocket::API::Event.create("open"))
+      @client.add_listener(Faye::WebSocket::API::Event.create("message"))
+      @client.add_listener(Faye::WebSocket::API::Event.create("close"))
+      @client.add_listener(Faye::WebSocket::API::Event.create("error"))
+    end
+  end
+
+  def add_audio_chunk(chunk:)
+    @data_size += chunk.size
+    @queue << chunk
+  end
+
+  def stop_audio
+    @mic_running = false
+  end
+
+  private
+
+  def on_connect(_response)
+    @callback.on_connected
+  end
+
+  def build_start_message(options:)
+    options["action"] = "start"
+    options.to_json
+  end
+
+  def build_close_message
+    { "action" => "close" }.to_json
+  end
+
+  def send_audio(data:)
+    if @chunk_data
+      if @mic_running
+        @queue.empty? ? send_chunk(chunk: nil, final: false) : send_chunk(chunk: @queue.pop(true), final: false)
+      elsif @queue.length == 1
+        send_chunk(chunk: @queue.pop(true), final: true)
+        @queue.close
+        @timer.cancel if @timer.respond_to?(:cancel)
+        return
+      else
+        send_chunk(chunk: @queue.pop(true), final: false) unless @queue.empty?
+      end
+    else
+      if @bytes_sent + ONE_KB >= @data_size
+        if @data_size > @bytes_sent
+          send_chunk(chunk: data.read(ONE_KB), final: true)
+          @timer.cancel if @timer.respond_to?(:cancel)
+          return
+        end
+        @timer.cancel if @timer.respond_to?(:cancel)
+      end
+      send_chunk(chunk: data.read(ONE_KB), final: false)
+    end
+    @timer = EventMachine::Timer.new(TEN_MILLISECONDS) { send_audio(data: data) }
+  end
+
+  def extract_transcripts(alternatives:)
+    transcripts = []
+    unless alternatives.nil?
+      alternatives.each do |alternative|
+        transcript = {}
+        transcript["confidence"] = alternative["confidence"] if alternative.key?("confidence")
+        transcript["transcript"] = alternative["transcript"]
+        transcripts << transcript
+      end
+    end
+    transcripts
+  end
+
+  def send_chunk(chunk:, final: false)
+    return if chunk.nil?
+    @bytes_sent += chunk.size
+    @client.send(chunk.bytes)
+    @client.send({ "action" => "stop" }.to_json) if final
+    @timer.cancel if @timer.respond_to?(:cancel) && final
+  end
+end

data/rakefile

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "dotenv/tasks"
+require "rake/testtask"
+require "rubocop/rake_task"
+
+task default: %w[def]
+
+RuboCop::RakeTask.new
+
+namespace :test do
+  Rake::TestTask.new do |t|
+    t.name = "unit"
+    t.description = "Run unit tests"
+    t.libs << "test"
+    t.test_files = FileList["test/unit/*.rb"]
+    t.verbose = true
+    t.warning = true
+  end
+
+  Rake::TestTask.new do |t|
+    t.name = "integration"
+    t.description = "Run integration tests (put credentials in a .env file)"
+    t.libs << "test"
+    t.test_files = FileList["test/integration/*.rb"]
+    t.verbose = true
+    t.warning = true
+    t.deps = [:dotenv]
+  end
+end
+
+desc "Run unit & integration tests"
+task :test do
+  Rake::Task["test:unit"].invoke
+  Rake::Task["test:integration"].invoke
+end
+
+desc "Run tests and generate a code coverage report"
+task :coverage do
+  ENV["COVERAGE"] = "true"
+  Rake::Task["test"].execute
+end
+
+task def: %i[rubocop coverage] do
+end