semantria_sdk 3.0.70

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 04b3da4fca72c6e121e2fbfabc778618c658def2
+  data.tar.gz: 2a2817917a43a6a7e3ae23bba763d6f080120f84
+SHA512:
+  metadata.gz: 435630637706c28637950627c4fb11a9fbd44a25c194d58832dae51698f97e0881f9f02bcbbbebb100ebdf61862644573453e693ad64537a51c5b8679c10da6e
+  data.tar.gz: 04865e65dbc60baf0ed032b3d54737ed0549a26a1a6f08b4d89eefc349eec8cc65f03377544a097297e52fc3f737a6bdc0d5aed9545fe55f4621c333dfc1c79f

data/lib/semantria.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+require_relative 'semantria/version'
+require_relative 'semantria/session'
+require_relative 'semantria/authrequest'
+require_relative 'semantria/jsonserializer'

data/lib/semantria/authrequest.rb

@@ -0,0 +1,165 @@
+# encoding: utf-8
+require 'uri'
+require 'base64'
+require 'cgi'
+require 'digest/md5'
+require 'openssl'
+require 'digest/sha1'
+require 'net/http'
+require 'net/https'
+
+OAUTH_VERSION = '1.0'
+OAuthParameterPrefix = "oauth_"
+OAuthConsumerKeyKey = "oauth_consumer_key"
+OAuthVersionKey = "oauth_version"
+OAuthSignatureMethodKey = "oauth_signature_method"
+OAuthSignatureKey = "oauth_signature"
+OAuthTimestampKey = "oauth_timestamp"
+OAuthNonceKey = "oauth_nonce"
+
+class AuthRequest
+  # Create a new instance
+  def initialize(consumer_key, consumer_secret, application_name, use_compression = false)
+    @consumer_key = consumer_key
+    @consumer_secret = consumer_secret
+    @application_name = application_name
+    @use_compression = use_compression
+  end
+
+  def authWebRequest(method, url, post_data = nil)
+    nonce = generateNonce()
+    timestamp = generateTimestamp()
+    query = generate_query(method, url, timestamp, nonce)
+    auth_header = generate_auth_header(query, timestamp, nonce)
+    headers = {'Authorization' => auth_header}
+
+    headers['Content-type'] = 'application/x-www-form-urlencoded' if method == 'POST'
+    headers['x-api-version'] = '3'
+    headers['x-app-name'] = @application_name
+
+    headers['Accept-Encoding'] = 'gzip' if @use_compression
+
+    uri = URI.parse(query)
+    conn = Net::HTTP.new(uri.host, 443)
+    conn.use_ssl = true
+    conn.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+    path = uri.request_uri #'%s?%s' % [qpath, qquery]
+    request = get_request(method, path, headers, post_data)
+    response = conn.request(request)
+
+    data = nil
+    if response.header['Content-Encoding'].eql? 'gzip'
+      sio = StringIO.new( response.body )
+      gz = Zlib::GzipReader.new( sio )
+      data = gz.read()
+    else
+      data = response.body
+    end
+
+    {status: response.code.to_i, reason: response.message, data: data}
+  end
+
+  private
+  # create the http request object for a given http_method and path
+  def get_request(method, path, headers, post_data = nil)
+    request = nil
+    case method
+      when 'POST'
+        request = Net::HTTP::Post.new(path, headers)
+      when 'PUT'
+        request = Net::HTTP::Put.new(path, headers)
+      when 'GET'
+        request = Net::HTTP::Get.new(path, headers)
+      when 'DELETE'
+        request = Net::HTTP::Delete.new(path, headers)
+      else
+        fail ArgumentError, "Don't know how to handle method: :#{method}"
+    end
+
+    unless post_data.nil?
+      request.body = post_data
+      request['Content-Length'] = request.body.length.to_s
+    end
+
+    request
+  end
+
+  def generate_query(method, url, timestamp, nonce)
+    uri = URI.parse(url)
+    np = get_normalized_parameters(timestamp, nonce)
+
+    if uri.query
+      uri.query = '%s&%s' % [uri.query, np]
+    else
+      uri.query = '%s' % np
+    end
+
+    uri.to_s
+  end
+
+  def generate_auth_header(query, timestamp, nonce)
+    md5cs = get_md5_hash(@consumer_secret)
+    esc_query = escape(query)
+    hash = get_sha1(md5cs, esc_query)
+    hash = escape(hash)
+
+    items = Hash.new()
+    items['OAuth realm'] = ''
+    items[OAuthVersionKey] = "%s" % OAUTH_VERSION
+    items[OAuthTimestampKey] = "%s" % timestamp
+    items[OAuthNonceKey] = "%s" % nonce
+    items[OAuthSignatureMethodKey] = "HMAC-SHA1"
+    items[OAuthConsumerKeyKey] = "%s" % @consumer_key
+    items[OAuthSignatureKey] = "%s" % hash
+
+    params = []
+    items.keys.sort.each do |key|
+      params.push('%s="%s"' % [key, items[key]])
+    end
+
+    params.join(',')
+  end
+
+  def get_normalized_parameters(timestamp, nonce)
+    items = Hash.new()
+    items[OAuthVersionKey] = OAUTH_VERSION
+    items[OAuthTimestampKey] = timestamp
+    items[OAuthNonceKey] = nonce
+    items[OAuthSignatureMethodKey] = "HMAC-SHA1"
+    items[OAuthConsumerKeyKey] = @consumer_key
+
+    params = []
+    for key in items.keys.sort
+      params.push('%s=%s' % [key, items[key]])
+    end
+
+    np = params.join('&')
+    # Encode signature parameters per Oauth Core 1.0 protocol
+    # Spaces must be encoded with "%20" instead of "+"
+    return np.gsub('+', '%20').gsub('%7E', '~')
+  end
+
+  def get_md5_hash(str)
+    md5hash = Digest::MD5.hexdigest(str)
+  end
+
+  def get_sha1(md5cs, query)
+    digest = OpenSSL::Digest::Digest.new('sha1')
+    # our composite signing key now has the token secret after the ampersand
+    sha1res = OpenSSL::HMAC.digest(digest, md5cs, query)
+    Base64.encode64(sha1res).chomp.gsub(/\n/, '')
+  end
+
+  def generateTimestamp()
+    Time.now.to_i.to_s
+  end
+
+  def generateNonce(length = 20)
+    rand(10 ** length).to_s.rjust(length, '0')
+  end
+
+  def escape(s)
+    CGI::escape(s)
+  end
+end  

data/lib/semantria/jsonserializer.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+require 'json'
+
+class JsonSerializer
+  def gettype
+    'json'
+  end
+
+  def serialize(obj, wrapper = nil)
+    str = JSON.generate(obj)
+
+    str.encoding.name != 'UTF-8' ? str.encode('UTF-8') : str
+  end
+
+  def deserialize(str, handler = nil)
+    JSON.parse(str)
+  end
+end

data/lib/semantria/session.rb

@@ -0,0 +1,564 @@
+# encoding: utf-8
+#$LOAD_PATH << File.dirname(__FILE__) unless $LOAD_PATH.include?(File.dirname(__FILE__))
+require_relative 'version'
+require_relative 'authrequest'
+require_relative 'jsonserializer'
+
+class Session
+  attr_accessor :host
+
+  # Create a new instance
+  def initialize(consumer_key, consumer_secret, application_name = nil, use_compression = false, serializer = nil)
+    @host = 'https://api30.semantria.com'
+    @wrapper_name = "Ruby/#{Semantria::VERSION}"
+    @consumer_key = consumer_key
+    @consumer_secret = consumer_secret
+    @use_compression = use_compression
+
+    if application_name.nil?
+      @application_name = @wrapper_name
+    else
+      @application_name = '%s/%s' % [application_name, @wrapper_name]
+    end
+
+    if serializer.nil?
+      #set default json serializer
+      @serializer = JsonSerializer.new()
+      @format = @serializer.gettype()
+    else
+      @serializer = serializer
+      @format = @serializer.gettype()
+    end
+  end
+
+  def registerSerializer(serializer)
+    fail 'Serializer can\'t be null' if serializer.nil?
+
+    @serializer = serializer
+    @format = serializer.gettype()
+  end
+
+  def setCallbackHandler(callback)
+    if callback.class < CallbackHandler
+      @callback = callback
+    else
+      fail "Parameter is not subclass of CallbackHandler #{callback}"
+    end
+  end
+
+  def getStatus
+    url = "#@host/status.#@format"
+    runRequest('GET', url, 'get_status')
+  end
+
+  def getSubscription
+    url = "#@host/subscription.#@format"
+    runRequest('GET', url, 'get_subscription')
+  end
+
+  def getStatistics
+    url = "#@host/statistics.#@format"
+    runRequest('GET', url, 'get_statistics')
+  end
+
+  def getConfigurations
+    url = "#@host/configurations.#@format"
+    result = runRequest('GET', url, 'get_configurations')
+    result ||= []
+  end
+
+  def addConfigurations(items)
+    updateConfigurations(items)
+  end
+
+  def updateConfigurations(items)
+    url = "#@host/configurations.#@format"
+    wrapper = get_type_wrapper('update_configurations')
+    data = @serializer.serialize(items, wrapper)
+    runRequest('POST', url, nil, data)
+  end
+
+  def deleteConfigurations(items)
+    url = "#@host/configurations.#@format"
+
+    wrapper = get_type_wrapper('delete_configurations')
+    data = @serializer.serialize(items, wrapper)
+    runRequest('DELETE', url, nil, data)
+  end
+
+  def getBlacklist(config_id = nil)
+    if config_id.nil?
+      url = "#@host/blacklist.#@format"
+    else
+      url = "#@host/blacklist.#@format?config_id=#{config_id}"
+    end
+
+    result = runRequest('GET', url, 'get_blacklist')
+    result ||= []
+  end
+
+  def addBlacklist(items, config_id = nil)
+    updateBlacklist(items, config_id)
+  end
+
+  def updateBlacklist(items, config_id = nil)
+    if config_id.nil?
+      url = "#@host/blacklist.#@format"
+    else
+      url = "#@host/blacklist.#@format?config_id=#{config_id}"
+    end
+
+    wrapper = get_type_wrapper('update_blacklist')
+    data = @serializer.serialize(items, wrapper)
+    runRequest('POST', url, nil, data)
+  end
+
+  def removeBlacklist(items, config_id = nil)
+    if config_id.nil?
+      url = "#@host/blacklist.#@format"
+    else
+      url = "#@host/blacklist.#@format?config_id=#{config_id}"
+    end
+
+    wrapper = get_type_wrapper('remove_blacklist')
+    data = @serializer.serialize(items, wrapper)
+    runRequest('DELETE', url, nil, data)
+  end
+
+  def getCategories(config_id = nil)
+    if config_id.nil?
+      url = "#@host/categories.#@format"
+    else
+      url = "#@host/categories.#@format?config_id=#{config_id}"
+    end
+
+    result = runRequest('GET', url, 'get_categories')
+    result ||= []
+  end
+
+  def addCategories(items, config_id = nil)
+    updateCategories(items, config_id)
+  end
+
+  def updateCategories(items, config_id = nil)
+    if config_id.nil?
+      url = "#@host/categories.#@format"
+    else
+      url = "#@host/categories.#@format?config_id=#{config_id}"
+    end
+
+    wrapper = get_type_wrapper('update_categories')
+    data = @serializer.serialize(items, wrapper)
+    runRequest('POST', url, nil, data)
+  end
+
+  def removeCategories(items, config_id = nil)
+    if config_id.nil?
+      url = "#@host/categories.#@format"
+    else
+      url = "#@host/categories.#@format?config_id=#{config_id}"
+    end
+
+    wrapper = get_type_wrapper('remove_categories')
+    data = @serializer.serialize(items, wrapper)
+    runRequest('DELETE', url, nil, data)
+  end
+
+  def getQueries(config_id = nil)
+    if config_id.nil?
+      url = "#@host/queries.#@format"
+    else
+      url = "#@host/queries.#@format?config_id=#{config_id}"
+    end
+
+    result = runRequest('GET', url, 'get_queries')
+    result ||= []
+  end
+
+  def addQueries(items, config_id = nil)
+    updateQueries(items, config_id)
+  end
+
+  def updateQueries(items, config_id = nil)
+    if config_id.nil?
+      url = "#@host/queries.#@format"
+    else
+      url = "#@host/queries.#@format?config_id=#{config_id}"
+    end
+
+    wrapper = get_type_wrapper('update_queries')
+    data = @serializer.serialize(items, wrapper)
+    runRequest('POST', url, nil, data)
+  end
+
+  def removeQueries(items, config_id = nil)
+    if config_id.nil?
+      url = "#@host/queries.#@format"
+    else
+      url = "#@host/queries.#@format?config_id=#{config_id}"
+    end
+
+    wrapper = get_type_wrapper('remove_queries')
+    data = @serializer.serialize(items, wrapper)
+    runRequest('DELETE', url, nil, data)
+  end
+
+  def getPhrases(config_id = nil)
+    if config_id.nil?
+      url = "#@host/phrases.#@format"
+    else
+      url = "#@host/phrases.#@format?config_id=#{config_id}"
+    end
+
+    result = runRequest('GET', url, 'get_sentiment_phrases')
+    result ||= []
+  end
+
+  def addPhrases(items, config_id = nil)
+    updatePhrases(items, config_id)
+  end
+
+  def updatePhrases(items, config_id = nil)
+    if config_id.nil?
+      url = "#@host/phrases.#@format"
+    else
+      url = "#@host/phrases.#@format?config_id=#{config_id}"
+    end
+
+    wrapper = get_type_wrapper('update_sentiment_phrases')
+    data = @serializer.serialize(items, wrapper)
+    runRequest('POST', url, nil, data)
+  end
+
+  def removePhrases(items, config_id = nil)
+    if config_id.nil?
+      url = "#@host/phrases.#@format"
+    else
+      url = "#@host/phrases.#@format?config_id=#{config_id}"
+    end
+
+    wrapper = get_type_wrapper('remove_phrases')
+    data = @serializer.serialize(items, wrapper)
+    runRequest('DELETE', url, nil, data)
+  end
+
+  def getEntities(config_id = nil)
+    if config_id.nil?
+      url = "#@host/entities.#@format"
+    else
+      url = "#@host/entities.#@format?config_id=#{config_id}"
+    end
+
+    result = runRequest('GET', url, 'get_entities')
+    result ||= []
+  end
+
+  def addEntities(items, config_id = nil)
+    updateEntities(items, config_id)
+  end
+
+  def updateEntities(items, config_id = nil)
+    if config_id.nil?
+      url = "#@host/entities.#@format"
+    else
+      url = "#@host/entities.#@format?config_id=#{config_id}"
+    end
+
+    wrapper = get_type_wrapper('update_entities')
+    data = @serializer.serialize(items, wrapper)
+    runRequest('POST', url, nil, data)
+  end
+
+  def removeEntities(items, config_id = nil)
+    if config_id.nil?
+      url = "#@host/entities.#@format"
+    else
+      url = "#@host/entities.#@format?config_id=#{config_id}"
+    end
+
+    wrapper = get_type_wrapper('remove_entities')
+    data = @serializer.serialize(items, wrapper)
+    runRequest('DELETE', url, nil, data)
+  end
+
+  def queueDocument(task, config_id = nil)
+    if config_id.nil?
+      url = "#@host/document.#@format"
+    else
+      url = "#@host/document.#@format?config_id=#{config_id}"
+    end
+
+    wrapper = get_type_wrapper('queue_document')
+    data = @serializer.serialize(task, wrapper)
+    result = runRequest('POST', url, 'get_processed_documents', data)
+    if result != nil && result.is_a?(Array)
+      onDocsAutoResponse(result)
+      200
+    else
+      result
+    end
+  end
+
+  def queueBatch(batch, config_id = nil)
+    if config_id.nil?
+      url = "#@host/document/batch.#@format"
+    else
+      url = "#@host/document/batch.#@format?config_id=#{config_id}"
+    end
+
+    wrapper = get_type_wrapper('queue_batch_documents')
+    data = @serializer.serialize(batch, wrapper)
+    result = runRequest('POST', url, 'get_processed_documents', data)
+    if result != nil && result.is_a?(Array)
+      onDocsAutoResponse(result)
+      200
+    else
+      result
+    end
+  end
+
+  def getDocument(doc_id, config_id = nil)
+    fail 'Document ID is nil or empty' if doc_id.nil?
+
+    if config_id.nil?
+      url = "#@host/document/#{doc_id}.#@format"
+    else
+      url = "#@host/document/#{doc_id}.#@format?config_id=#{config_id}"
+    end
+
+    runRequest('GET', url, 'get_document')
+  end
+
+  def cancelDocument(doc_id, config_id = nil)
+    fail 'Document ID is nil or empty' if doc_id.nil?
+
+    if config_id.nil?
+      url = "#@host/document/#{doc_id}.#@format"
+    else
+      url = "#@host/document/#{doc_id}.#@format?config_id=#{config_id}"
+    end
+
+    runRequest('DELETE', url)
+  end
+
+  def getProcessedDocuments(config_id = nil)
+    if config_id.nil?
+      url = "#@host/document/processed.#@format"
+    else
+      url = "#@host/document/processed.#@format?config_id=#{config_id}"
+    end
+
+    result = runRequest('GET', url, 'get_processed_documents')
+    result ||= []
+  end
+
+  def queueCollection(task, config_id = nil)
+    if config_id.nil?
+      url = "#@host/collection.#@format"
+    else
+      url = "#@host/collection.#@format?config_id=#{config_id}"
+    end
+
+    wrapper = get_type_wrapper('queue_collection')
+    data = @serializer.serialize(task, wrapper)
+    result = runRequest('POST', url, 'get_processed_collections', data)
+    if result != nil && result.is_a?(Array)
+      onCollsAutoResponse(result)
+      200
+    else
+      result
+    end
+  end
+
+  def getCollection(id, config_id = nil)
+    fail 'Collection ID is nil or empty' if id.nil?
+
+    if config_id.nil?
+      url = "#@host/collection/#{id}.#@format"
+    else
+      url = "#@host/collection/#{id}.#@format?config_id=#{config_id}"
+    end
+
+    runRequest('GET', url, 'get_collection')
+  end
+
+  def cancelCollection(id, config_id = nil)
+    fail 'Collection ID is nil or empty' if id.nil?
+
+    if config_id.nil?
+      url = "#@host/collection/#{id}.#@format"
+    else
+      url = "#@host/collection/#{id}.#@format?config_id=#{config_id}"
+    end
+
+    runRequest('DELETE', url)
+  end
+
+  def getProcessedCollections(config_id = nil)
+    if config_id.nil?
+      url = "#@host/collection/processed.#@format"
+    else
+      url = "#@host/collection/processed.#@format?config_id=#{config_id}"
+    end
+
+    result = runRequest('GET', url, 'get_processed_collections')
+    result ||= []
+  end
+
+  private
+  def runRequest(method, url, type = nil, post_data = nil)
+    request = AuthRequest.new(@consumer_key, @consumer_secret, @application_name, @use_compression)
+    onRequest({'method' => method, 'url' => url, 'message' => post_data})
+    response = request.authWebRequest(method, url, post_data)
+    onResponse({'status' => response[:status], 'reason' => response[:reason], 'message' => response[:data]})
+
+    status = response[:status]
+    message = response[:reason]
+
+    message = response[:data] unless response[:data].to_s.empty?
+
+    if method == 'DELETE'
+      if status == 200 || status == 202
+        return status
+      else
+        resolve_error(status, message)
+        return status
+      end
+    else
+      if status == 200
+        handler = get_type_handler(type)
+        message = @serializer.deserialize(response[:data], handler)
+        return message
+      elsif status == 202
+        if method == 'POST'
+          return status
+        else
+          return nil
+        end
+      else
+        resolve_error(status, message)
+      end
+    end
+  end
+
+  def get_type_handler(type)
+    if @serializer.gettype() == 'json'
+      return nil
+    end
+
+    #only for xml serializer
+    case
+      when type == 'get_status' then return GetStatusHandler.new()
+      when type == 'get_subscription' then return GetSubscriptionHandler.new()
+      when type == 'get_configurations' then return GetConfigurationsHandler.new()
+      when type == 'get_blacklist' then return GetBlacklistHandler.new()
+      when type == 'get_categories' then return GetCategoriesHandler.new()
+      when type == 'get_queries' then return GetQueriesHandler.new()
+      when type == 'get_sentiment_phrases' then return GetSentimentPhrasesHandler.new()
+      when type == 'get_entities' then return GetEntitiesHandler.new()
+      when type == 'get_document' then return GetDocumentHandler.new()
+      when type == 'get_processed_documents' then return GetProcessedDocumentsHandler.new()
+      when type == 'get_collection' then return GetCollectionHandler.new()
+      when type == 'get_processed_collections' then return GetProcessedCollectionsHandler.new()
+      else return nil
+    end
+  end
+
+  def get_type_wrapper(type)
+    if @serializer.gettype() == 'json'
+      nil
+    end
+
+    #only for xml serializer
+    #if type == "update_configurations"
+    #  return {"root" => "configurations", "added" => "configuration", "removed" => "configuration"}
+    #elsif type == "update_blacklist"
+    #  return {"root" => "blacklist", "added" => "item", "removed" => "item"}
+    #elsif type == "update_categories"
+    #  return {"root" => "categories", "added" => "category", "removed" => "category", "samples" => "sample"}
+    #elsif type == "update_queries"
+    #  return {"root" => "queries", "added" => "query", "removed" => "query"}
+    #elsif type == "update_sentiment_phrases"
+    #  return {"root" => "phrases", "added" => "phrase", "removed" => "phrase"}
+    #elsif type == "update_entities"
+    #  return {"root" => "entities", "added" => "entity", "removed" => "entity"}
+    #elsif type == "queue_document"
+    #  return {"root" => "document"}
+    #elsif type == "queue_batch_documents"
+    #  return {"root" => "documents", "item" => "document"}
+    #elsif type == "queue_collection"
+    #  return {"root" => "collection", "documents" => "document"}
+    #else
+    #  return nil
+    #end
+  end
+
+  def resolve_error(status, message = nil)
+    if status == 400 || status == 401 || status == 402 || status == 403 || status == 406 || status == 500
+      onError({'status' => status, 'message' => message})
+    else
+      fail "HTTP error was found with status: #{status} and message: #{message}"
+    end
+  end
+
+  def onRequest(request)
+    unless @callback.nil?
+      @callback.onRequest(self, request)
+    end
+  end
+
+  def onResponse(response)
+    unless @callback.nil?
+      @callback.onResponse(self, response)
+    end
+  end
+
+  def onError(response)
+    unless @callback.nil?
+      @callback.onError(self, response)
+    end
+  end
+
+  def onDocsAutoResponse(response)
+    unless @callback.nil?
+      @callback.onDocsAutoResponse(self, response)
+    end
+  end
+
+  def onCollsAutoResponse(response)
+    unless @callback.nil?
+      @callback.onCollsAutoResponse(self, response)
+    end
+  end
+end
+
+class CallbackHandler
+  def initialize
+    fail 'Don\'t instantiate me!' if abstract_class?
+  end
+
+  private
+  def abstract_class?
+    self.class == CallbackHandler
+  end
+
+  def onRequest(sender, args)
+    fail 'Abstract method onRequest'
+  end
+
+  def onResponse(sender, args)
+    fail 'Abstract method onResponse'
+  end
+
+  def onError(sender, args)
+    fail 'Abstract method onError'
+  end
+
+  def onDocsAutoResponse(sender, args)
+    fail 'Abstract method onDocsAutoResponse'
+  end
+
+  def onCollsAutoResponse(sender, args)
+    fail 'Abstract method onCollsAutoResponse'
+  end
+end

data/lib/semantria/version.rb

@@ -0,0 +1,3 @@
+module Semantria
+  VERSION = '3.0.70'
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification
+name: semantria_sdk
+version: !ruby/object:Gem::Version
+  version: 3.0.70
+platform: ruby
+authors:
+- Semantria, LLC
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-14 00:00:00.000000000 Z
+dependencies: []
+description: |2-
+
+  Semantria is a text analytics and sentiment analysis API. It allows you to gain valuable
+  insights from your unstructured text content. It is based on Lexalytics’ Salience – a text
+  analytics and sentiment analysis engine. It is the same engine as the one being used by
+  Oracle, Cisco, Thomson Reuters, Saleforce.com - Radian6, Visible, Lithium, and 50+ other
+  leaders in the space.
+
+  Semantria offers Ruby SDK, that is the most convenient way to get started with the Semantria API on Ruby.
+  SDK implements all the available Semantria features and demonstrate best practices of API usage.
+email: support@semantria.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/semantria.rb
+- lib/semantria/session.rb
+- lib/semantria/version.rb
+- lib/semantria/authrequest.rb
+- lib/semantria/jsonserializer.rb
+homepage: https://semantria.com
+licenses:
+- GPL v3
+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.0.0
+signing_key: 
+specification_version: 4
+summary: Semantria Ruby SDK
+test_files: []