primal 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dfe6776b27a2665fb3bf680618ca23dcbeb623d4
+  data.tar.gz: c3e4f6c2e0757efa8af11ce30df9fe7842c91cdd
+SHA512:
+  metadata.gz: 6a1c0414e1d069298d3d30973483fac9b55d80644dcbe2917da33375012108da4e8472e8cdd211a0cfcd0dd41062f1ee291f0b6de33a381e69769f3f3b0cd9cd
+  data.tar.gz: 7e211be3602d8f589aa7bb7697482986c23cc97dbc78984d627b69bd060ae2baac1bc0072e56dc14343d7f1efc2e2b509b0f16d2910b8fe67fe393ebac405109

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.project

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>primal</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+	</buildSpec>
+	<natures>
+		<nature>com.aptana.projects.webnature</nature>
+		<nature>com.aptana.ruby.core.rubynature</nature>
+	</natures>
+</projectDescription>

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in primal.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 w2davids@gmail.com
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Primal
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'primal'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install primal
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/primal.rb

@@ -0,0 +1,5 @@
+require "primal/version"
+
+module Primal
+  # Your code goes here...
+end

data/lib/primal/AlchemyAPIWrapper.rb

@@ -0,0 +1,340 @@
+# We need to use some ruby gems
+require 'rubygems'
+require 'uri'
+require 'httparty'
+require 'json'
+
+module Primal
+
+
+#
+# The InputTermExtraction class abstracts accessing AlchemyAPI
+# (http://www.alchemyapi.com/) to extract important information from Web
+# pages/News articles/blog posts/plain text.
+#
+# The main function is getPrimalRequest, which accepts a string that represents
+# a Web page URL or some text, and build a Primal topic URI that will direct the
+# user to the Primal Web App.
+#
+class InputTermExtraction
+  include HTTParty
+
+  # Uncomment this next line to see what HTTParty is doing
+  # debug_output $stderr
+
+  # Set this to true/false in order to turn on/off debugging of this class
+  @@debugMe = true
+
+  @@alchemyRoot = "http://access.alchemyapi.com/calls"
+  @@alchemyURL = "#{@@alchemyRoot}/url"
+  @@alchemyText = "#{@@alchemyRoot}/text"
+
+  # change these variables to modify how the Primal request is built
+  @@entitiesLimit = 1
+  @@keywordsLimit = 3
+
+  # We ignore keywords that intersect with entities of the following types:
+  @@categoryIgnores = {
+    'person'            => 1,
+    'organization'      => 1,
+    'city'              => 1,
+    'company'           => 1,
+    'continent'         => 1,
+    'country'           => 1,
+    'region'            => 1,
+    'stateorcountry'    => 1,
+    'geographicfeature' => 1
+  }
+
+  #
+  # Constructor for the InputTermExtraction class
+  #
+  # Pass in the Api Key for Alchemy services. 
+  # You can register for a free API key here:
+  #     http://www.alchemyapi.com/api/register.html
+  # to test your application. 
+  # Please read the license of Alchemy API.
+  #
+  def initialize(alchemyApiKey)
+    @alchemyApiKey = alchemyApiKey
+  end
+
+  #
+  # Receives a string that represents a Web page URL or some text, and returns 
+  # a Primal topic URI.
+  #
+  # Returns nil on error
+  #
+  def getPrimalRequest(urlOrText)
+    if isURI(urlOrText)
+      getPrimalRequestURL(urlOrText)
+    else
+      getPrimalRequestTEXT(urlOrText)
+    end
+  end
+  
+  #
+  # Indicates whether or not a given string represents a URL
+  #
+  def isURI(string)
+    uri = URI.parse(string)
+    %w( http https ).include?(uri.scheme)
+  rescue URI::BadURIError
+    false
+  rescue URI::InvalidURIError
+    false
+  end
+  
+  #
+  # Processes the given URL at Alchemy and then translates the results to a
+  # valid Primal URL
+  #
+  def getPrimalRequestURL(urlToProcess)
+    if @@debugMe
+      $stderr.puts "Extracting information from URL..."
+    end
+
+    # get category of the Web page
+    categoryJSON = getAlchemy("#{@@alchemyURL}/URLGetCategory",
+                              :query => {
+                                 :outputMode => 'json',
+                                 :apikey => @alchemyApiKey,
+                                 :url => urlToProcess
+                             })
+
+    # get entities in the Web page
+    entitiesJSON = getAlchemy("#{@@alchemyURL}/URLGetRankedNamedEntities",
+                              :query => {
+                                :outputMode => 'json',
+                                :apikey => @alchemyApiKey,
+                                :url => urlToProcess
+                             })
+
+    # get keywords from the Web page
+    keywordsJSON = getAlchemy("#{@@alchemyURL}/URLGetRankedKeywords",
+                              :query => {
+                                :outputMode => 'json',
+                                :apikey => @alchemyApiKey,
+                                :url => urlToProcess
+                             })
+
+    buildPrimalRequest(categoryJSON, entitiesJSON, keywordsJSON)
+  end
+
+  #
+  # Processes the given Text at Alchemy and then translates the results to a
+  # valid Primal URL
+  #
+  def getPrimalRequestTEXT(textToProcess)
+    if @@debugMe
+      $stderr.puts "Extracting information from text..."
+    end
+
+    # get category
+    categoryJSON = postAlchemy("#{@@alchemyText}/TextGetCategory",
+                               :query => {
+                                 :outputMode => 'json',
+                                 :apikey => @alchemyApiKey,
+                                 :text => textToProcess
+                              })
+
+    # get entities
+    entitiesJSON = postAlchemy("#{@@alchemyText}/TextGetRankedNamedEntities",
+                               :query => {
+                                 :outputMode => 'json',
+                                 :apikey => @alchemyApiKey,
+                                 :text => textToProcess
+                              })
+
+    # get keywords
+    keywordsJSON = postAlchemy("#{@@alchemyText}/TextGetRankedKeywords",
+                               :query => {
+                                 :outputMode => 'json',
+                                 :apikey => @alchemyApiKey,
+                                 :text => textToProcess
+                              })
+
+    buildPrimalRequest(categoryJSON, entitiesJSON, keywordsJSON)
+  end
+
+  #
+  # Uses the deconstructed Alchemy information to create a valid Primal URL
+  #
+  def buildPrimalRequest(categoryJSON, entitiesJSON, keywordsJSON)
+    # Check if any of the extractions failed
+    if !categoryJSON or !entitiesJSON or !keywordsJSON
+       $stderr.puts "Cannot build Primal request. Alchemy failed to extract information."
+       return nil
+    end
+    
+    if @@debugMe
+      $stderr.puts "Building Primal request..."
+    end
+   
+    ### Get information required for building a Primal request
+    # Get the category from the extracted data
+    category = rewriteCategory(categoryJSON['category'])
+
+    if @@debugMe
+      $stderr.puts "Category = #{category}"
+    end
+        
+    ### Select top entities from all extracted entities
+    entitiesList = entitiesJSON['entities'].collect { |entity|
+      entity['text'].downcase
+    }[0, @@entitiesLimit]
+    
+    if @@debugMe
+      prettified = entitiesJSON['entities'].collect { |entity|
+        entity['text']
+      }.join(', ')
+      $stderr.puts "Entities = #{prettified}"
+    end
+    
+    ### Select top keywords from all extracted keywords
+    # Remove keywords that intersect with entities of the types in @@categoryIgnores
+    allEntities = entitiesJSON['entities'].select { |entity|
+      @@categoryIgnores.has_key? entity['type'].downcase
+    }.collect { |entity|
+      entity['text'].downcase
+    } 
+    
+    if @@debugMe
+      prettified = keywordsJSON['keywords'].collect { |keyword|
+        keyword['text']
+      }.join(', ')
+      $stderr.puts "Keywords = #{prettified}"
+    end
+    
+    keywordsList = keywordsJSON['keywords'].select { |keyword|
+      normalizedKw = keyword['text'].downcase
+      intersectsWithEntity = !(allEntities.select { |entity|
+                                   entity.include? normalizedKw or normalizedKw.include? entity
+                                 }.empty?)
+      # Ignore keywords > 4 words or those that intersect with entities
+      normalizedKw.split.size < 5 && !intersectsWithEntity
+    }.collect { |keyword|
+      keyword['text'].downcase
+    }
+      
+    # Remove repeated keywords
+    keywordsList = getNonRepeatedKeywords(keywordsList)
+    
+    ### Build Primal topic URI
+    primalRequest = ""
+    unless category.nil?     then primalRequest = "/" + category end
+    if entitiesList.size > 0 then primalRequest = primalRequest + "/" + entitiesList.join("/") end
+    if keywordsList.size > 0 then primalRequest = primalRequest + "/" + keywordsList.join(";") end
+    if @@debugMe
+      $stderr.puts "Primal request = #{primalRequest}"
+    end
+    URI::encode(primalRequest)
+  end #function
+
+  #
+  # Returns the top @@keywordsLimit keywords, ignoring those contained 
+  # within other keywords   
+  #
+  def getNonRepeatedKeywords(keywordsList)
+    # If there is less than @@keywordsLimit, or if the first @@keywordsLimit keywords
+    # are unique, return the first @@keywordsLimit keywords
+    repeatedKeywords = getRepeatedKeywords(keywordsList[0, @@keywordsLimit])
+    if keywordsList.length <= @@keywordsLimit or repeatedKeywords.empty?
+      keywordsList[0, @@keywordsLimit] 
+    else
+      # Remove repeated elements from the first @@keywordsLimit keywords, and recursively
+      # call this function
+      getNonRepeatedKeywords(keywordsList - repeatedKeywords)
+    end
+  end
+  
+  #
+  # Returns any repeated words in the list
+  #
+  def getRepeatedKeywords(keywordsList)
+    keywordsList.select { |keyword|
+           not(keywordsList.select { |other|
+             other != keyword and other.include? keyword
+           }.empty?)
+    }
+  end
+  
+  #
+  # Modifies the extracted category string to become a clear topic in the Primal
+  # request.
+  #
+  # AlchemyAPI categorizes text into a limited set of category types.
+  #
+  #    See http://www.alchemyapi.com/api/categ/categs.html for a complete list.
+  #
+  # Some of the cateogy type names have two strings concatenated by an
+  # underscore character. This function selects one of the two strings (or a
+  # totally new string) to be the topic in the Primal request.
+  #
+  def rewriteCategory(category)
+    case category
+    when "unknown"               # AlchemyAPI failed to classify the text
+      category = nil
+    when "arts_entertainment"    
+      category = "arts"          # rewrite to 'arts'
+    when "computer_internet"
+      category = "technology"    # rewrite to 'technology', a clearer topic for this category
+    when "culture_politics"
+      category = "politics"      # rewrite to 'politics'
+    when "law_crime"
+      category = "law"           # rewrite to 'law'
+    when "science_technology"
+      category = "science"       # rewrite to 'science'
+    else
+      # The previous conditions should cover all the categories extracted by
+      # Alchemy.  In case of a new category that contains an underscore, replace
+      # it and keep the two words as the topic. 
+      category = category.sub('_', ' ')
+    end
+  end
+
+  #
+  # Perform a POST request to Alchemy service URL and return the response as a
+  # JSON object
+  #
+  # Returns nil on error
+  #
+  def postAlchemy(serviceURL, parameters)
+    response = self.class.post(serviceURL, parameters)
+    returnAlchemyResponseJSON(response)
+  end
+  
+  #
+  # Perform a GET request to Alchemy service URL and return the 
+  # response as a JSON object
+  #
+  # Returns nil on error
+  #
+  def getAlchemy(serviceURL, parameters)
+    response = self.class.get(serviceURL, parameters)
+    returnAlchemyResponseJSON(response)
+  end
+
+  #
+  # Return the body of the response in a JSON object 
+  # or nil on error
+  #
+  def returnAlchemyResponseJSON(response)
+    code = response.code
+    body = response.body
+    bodyJSON = JSON.parse(body)
+
+    # A statusInfo field contains the details of the error 
+    if bodyJSON['status'] != "OK"
+      puts bodyJSON['statusInfo']
+      nil
+    else
+      bodyJSON
+    end
+  end
+end
+Ï
+
+end
+
+

data/lib/primal/PrimalAccess.rb

@@ -0,0 +1,204 @@
+require 'rubygems'
+require 'httparty'
+require 'json'
+
+module Primal
+  #
+  # The PrimalAccess class abstracts the access to Primal such
+  # that you can call simple methods on it to get what you need.
+  #
+  class PrimalAccess
+    include HTTParty
+    base_uri 'https://data.primal.com'
+    # Uncomment this next line to see what HTTParty is doing
+    # debug_output $stderr
+    # Set this to false in order to turn off debugging of this class
+    @@debugMe = true
+    #
+    # Constructor for the PrimalAccess class
+    #
+    # Pass in the username and password of the user you're going
+    # to access in order to construct and object that will work
+    # with that user
+    #
+    def initialize(appId, appKey, username, password)
+      @headers = {
+      :headers => {
+        'Primal-App-ID' => appId,
+        'Primal-App-Key' => appKey
+      },
+      :basic_auth => {
+        :username => username,
+        :password => password
+      }
+    }
+    end
+
+    #
+    # Sometimes we're going to get topics that are complex (i.e. they contain a
+    # scheme and host) and we want to simplify those.  Because we're not making
+    # calls with bare URLs but have told HTTParty what the base_uri is, we need to
+    # pull that base uri off of the topic, should it be there.
+    #
+    def extractJustTopic(topic)
+      topic.sub(%r{https://.*?/}, '/')
+    end
+
+    #
+    # POSTs a new topic to Primal in order to seed that topic.
+    #
+    # The 'topic' parameter will be used to construct a POST URL
+    # that looks like "/topic"
+    #
+    # Returns two values: the response code and the body.
+    # Anything but a response code of 201 is to be considered
+    # an error.
+    #
+    def postNewTopic(topic, opts = {})
+      topic = extractJustTopic(topic)
+      count = 0
+      code = 400
+      body = ''
+      options = @headers.merge(opts)
+      while (count < 5)
+        if @@debugMe
+          $stderr.puts "POSTing to #{topic}"
+        end
+        response = self.class.post("#{topic}", options)
+        code = response.code
+        body = response.body
+        #
+        # 400 - bad request
+        # 401 - application not authorized to access the user's account
+        # 403 - application not authorized to use Primal
+        #
+        if code >= 400 && code <= 403
+          if @@debugMe
+            $stderr.puts "POST received a #{code}"
+          end
+        break
+        #
+        # 429 - application has reached its request limit for the moment
+        #
+        elsif code == 429
+          # Sleep for 10 seconds
+          if @@debugMe
+            $stderr.puts "Got a 429.  Waiting (#{count})."
+          end
+          sleep 10
+        count += 1
+        #
+        # 201 - success
+        #
+        elsif code == 201
+          if @@debugMe
+            $stderr.puts "POST successful"
+          end
+        break
+        else
+          abort "Received unexpected response code (#{code}) for POST #{uri}"
+        end
+      end
+      return code, body
+    end
+
+    #
+    # Uses the pre-existing topic to filter the default source
+    # of content through the interest network defined by the topic.
+    #
+    # The given parameter will be used to construct a GET URL
+    # that looks like "/topic"
+    #
+    # You can pass a dictionary of optional arguments that will
+    # be merged in to the query parameters, if you wish.
+    # e.g.
+    #   { :"primal:contentScore:min" => 0.7 }
+    #   { :"primal:contentCount:max" => 5 }
+    #   { :contentSource => MyDataSource } ... or ...
+    #   { :contentSource => PrimalSource }
+    #
+    # Returns two values: the response code, and the body.
+    # If successful (i.e. a response code of 200) then the body
+    # will be the JSON payload of the filtered content.
+    #
+    def filterContent(topic, opts = {})
+      topic = extractJustTopic(topic)
+      count = 0
+      code = 400
+      body = ''
+      options = @headers.merge({ :query => {
+          :timeOut => 'max'
+        }.merge(opts)
+      })
+      while (count < 10)
+        if @@debugMe
+          $stderr.puts "GETting #{topic}"
+        end
+        response = self.class.get("#{topic}", options)
+        code = response.code
+        body = response.body
+        #
+        # 400 - bad request
+        # 401 - application not authorized to access the user's account
+        # 403 - application not authorized to use Primal
+        # 404 - object not found
+        #
+        if code >= 400 && code <= 404
+          if @@debugMe
+            $stderr.puts "GET received a #{code}"
+          end
+        break
+        #
+        # 429 - application has reached its request limit for the moment
+        #
+        elsif code == 429
+          if @@debugMe
+            $stderr.puts "Got a 429.  Waiting (#{count})."
+          end
+          # Sleep for 10 seconds
+          sleep 10
+        # We don't allow as many retries when we might be throttled
+        count += 2
+        #
+        # 200 - success
+        #
+        elsif code == 200
+          if @@debugMe
+            $stderr.puts "Results are complete"
+          end
+        break
+        #
+        # We don't know what happened but it can't be good
+        #
+        else
+          abort "Received unexpected response code (#{code}) for GET #{topic}"
+        end
+      end
+      return code, body
+    end
+
+    #
+    # This is a convenience method that will POST the topic to
+    # Primal and then filter the default source of content through the
+    # resulting interest network.
+    #
+    # The response from this method is a bit less clear than using
+    # a POST and filter explicitly, since you may not know which
+    # one of the two operations has failed (assuming a failure).
+    #
+    # Returns two values: the response code and the body.  The only
+    # successful response code from this method is 200.  If
+    # successful then the body contains the JSON payload of the
+    # filtered content.
+    #
+    def postThenFilter(topic, opts = {})
+      code, body = postNewTopic(topic)
+      if code == 201
+        code, body = filterContent(topic, opts)
+      end
+      return code, body
+    end
+  end
+
+end
+

data/lib/primal/version.rb

@@ -0,0 +1,3 @@
+module Primal
+  VERSION = "0.0.1"
+end

data/primal.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'primal/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "primal"
+  spec.version       = Primal::VERSION
+  spec.authors       = ["w2davids@gmail.com"]
+  spec.email         = ["w2davids@gmail.com"]
+  spec.description   = %q{Ruby gem for accessing Primal Data web services}
+  spec.summary       = %q{Ruby client to access Primal Data web services}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.rubyforge_project = "primal"
+  
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "json"
+  spec.add_development_dependency "httparty"
+  
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: primal
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- w2davids@gmail.com
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ruby gem for accessing Primal Data web services
+email:
+- w2davids@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .project
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/primal.rb
+- lib/primal/AlchemyAPIWrapper.rb
+- lib/primal/PrimalAccess.rb
+- lib/primal/version.rb
+- primal.gemspec
+homepage: ''
+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: primal
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Ruby client to access Primal Data web services
+test_files: []