havenondemand 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a52f32e712338fbd323f1e7a584ab9f3fc44cc03
+  data.tar.gz: e37d432c750aea108909076cf0a0e63e1f2c02bd
+SHA512:
+  metadata.gz: 9831a62983b60163edd61293f9462825769bacae05331037af3994745dc7be5aa7f5aa3c77da47d7a1bee8bfd32798342cc2907e63a98b43b184cd1257542ca9
+  data.tar.gz: 30f9608b194bdbb656a0895509ba6af352466f9f3fbb95fc4b9b69ff635ac3cb90b4dc90d679238b98d6a6f8c69f5c81aa2c4ff08d6d31699611448ab6a1e8cc

data/.gitignore

@@ -0,0 +1 @@
+*.gem

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 TODO: Write your name
+
+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,190 @@
+# Ruby gem for Haven OnDemand
+Official client library to help with calling Haven OnDemand APIs [http://havenondemand.com](http://havenondemand.com).
+
+## What is Haven OnDemand?
+Haven OnDemand is a set of over 70 APIs for handling all sorts of unstructured data. Here are just some of our APIs' capabilities:
+* Speech to text
+* OCR
+* Text extraction
+* Indexing documents
+* Smart search
+* Language identification
+* Concept extraction
+* Sentiment analysis
+* Web crawlers
+* Machine learning
+
+For a full list of all the APIs and to try them out, check out https://www.havenondemand.com/developer/apis
+
+
+## Installation
+
+To install from rubygems.org.
+
+```
+gem install havenondemand
+```
+
+To install the latest version from this github repo, use the specific_install gem.
+
+```
+gem install specific_install
+gem specific_install https://github.com/HP-Haven-OnDemand/havenondemand-ruby
+```
+
+
+## Usage
+
+
+### Importing
+When using rails and other frameworks with a gem file, include it in it.
+```ruby
+gem "havenondemand"
+```
+Or, require it directly in your app.
+```ruby
+require "havenondemand"
+```
+
+###Initializing the client
+*Note*: URL endpoint will change in the near future to
+```ruby
+client = HODClient.new("http://api.idolondemand.com", $apikey)
+```
+
+All that is needed to initialize the client is an apikey and the url of the API.
+
+
+###Sending requests
+
+```ruby
+r = client.post('analyzesentiment', {:text=>'I like cats'})
+```
+The client's *post* method takes the apipath that you're sending your request to as well as an object containing the parameters you want to send to the api. You do not need to send your apikey each time as the client will handle that automatically
+
+###Posting files
+```ruby
+r = client.post('ocrdocument', {:file=>File.new("/path/to/file", 'rb')})
+```
+Sending files is just as easy.
+
+```ruby
+r = client.post('ocrdocument', {:mode=>'photo',:file=>File.new("/path/to/file", 'rb')})
+r = client.post('ocrdocument', {:mode=>'photo',:file=>File.new("/path/to/file", 'rb')})
+```
+Any extra parameters should be added in the same way as regular calls, or in the data parameter.
+
+###Parsing the output
+
+```ruby
+myjson = r.json()
+```
+
+The object returned is a response object from the python [requests library](http://docs.python-requests.org/en/latest/) and can easily be turned to json.
+
+```ruby
+docs = myjson["documents"]
+array.each {|doc| puts doc["title"] }
+```
+
+###Indexing
+
+**Creating an index**
+
+```ruby
+index = client.createIndex("mytestindex", flavor="explorer")
+```
+
+An Index object can easily be created
+
+**Fetching indexes/an index**
+
+```ruby
+index = client.getIndex('myindex')
+```
+The getIndex call will return an hodindex Index object but will not check for existence.
+
+```ruby
+indexes = client.listIndexes()
+indexes.fetch('myindex', client.createIndex('myindex'))
+```
+
+Here we first check the list of our indexes and return a newly created index if the index does not already exist
+
+**Deleting an index**
+
+```ruby
+index.delete()
+client.deleteIndex('myindex')
+```
+An index can be deleted in two equivalent ways
+
+**Indexing documents**
+
+```ruby
+doc1 = HODDoc.new({title: "title1", reference: "doc1", content: "my content 1"})
+doc2 = HODDoc.new({title: "title2", reference: "doc2", content: "my content 2"})
+```
+Documents can be created as regular python objects
+
+```
+index.addDoc(doc1)
+index.addDocs([doc1,doc2])
+```
+
+They can be added directly one at a time or in a batch.
+
+```
+for doc in docs:
+  index.pushDoc(doc)
+index.commit()
+```
+
+An alternative to *addDocs* and easy way to keep batch documents is to use the pushDoc method, the index will keep in memory a list of the documents it needs to index.
+
+```
+if index.countDocs()>10:
+  index.commit()
+```
+
+It makes it easy to batch together groups of documents.
+
+####Indexing - Connectors
+
+```ruby
+client = HODClient.new("http://api.idolondemand.com", $apikey)
+conn = HODConnector.new("mytestconnector", client)
+conn.create(type="web", config = { "url" => "http://www.idolondemand.com" })
+conn.delete()
+```
+
+
+### Asynchronous request
+
+For each call the Async parameter can be set to true to send an asynchronous request.
+
+```ruby
+r = client.post('analyzesentiment', {:text => 'I like cats'}, async = true)
+print r.json()
+
+# will return status of call, queued or finished
+puts r.status().json()
+# Will wait until result to return
+puts r.result().json()
+```
+
+Same thing for indexing.
+
+```ruby
+r = index.commit(async = true)
+```
+
+
+
+## Contributing
+
+1. Fork it ( https://github.com/HP-Haven-OnDemand/havenondemand-ruby/fork )
+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 a new Pull Request

data/Rakefile

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

data/examples/examples.rb

@@ -0,0 +1,67 @@
+require_relative "../lib/havenondemand.rb"
+
+$apikey="yourapikey"
+
+
+
+def test_post
+  client= HODClient.new("http://api.idolondemand.com",$apikey)
+  r=client.post("querytextindex",{:text=>"hello",:absolute_max_result=>1000})
+  puts "\n",r.json()["documents"][0]["reference"],"\n"
+end
+
+
+def test_post_async
+  client= HODClient.new("http://api.idolondemand.com",$apikey)
+  r=client.post("querytextindex",{:text=>"hello"},async=true)
+  #returns jobid
+  puts r.jobID
+  # will return status of call, queued or finished
+  puts r.status().json()
+  # Will wait until result to return
+  puts r.result().json()
+end
+
+
+
+def test_indexing(index="mytestindex")
+  client= HODClient.new("http://api.idolondemand.com",$apikey)
+  index=client.getIndex("myrssdb")
+
+  doc={:title=>"title",:reference=>"ref",:content=>"content"}
+  index.pushDoc(doc)
+  puts index.commit().json()
+end
+
+
+
+def test_createIndex
+  client= HODClient.new("http://api.idolondemand.com",$apikey)
+  index=client.createIndex("mytestindex",flavor="explorer")
+  puts index.json()
+end
+
+
+
+def test_deleteIndex
+  client= HODClient.new("http://api.idolondemand.com",$apikey)
+  puts client.deleteIndex("mytestindex")
+end
+
+def test_createConnector
+  client= HODClient.new("http://api.idolondemand.com",$apikey)
+  conn=HODConnector.new("mytestconnector",client)
+  puts conn.create(type="web",config={ "url" => "http://www.idolondemand.com" })
+  puts conn.delete()
+end
+
+def test_sentiment
+
+  client= HODClient.new("http://api.idolondemand.com",$apikey)
+  r=client.post('analyzesentiment',{'text'=>'I like cats'})
+  puts r.json()
+end
+
+test_sentiment()
+
+#test_createIndex()

data/examples/testhelper.rb

@@ -0,0 +1,2 @@
+require_relative "../lib/havenondemand"
+require "test/unit"

data/havenondemand.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'havenondemand/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "havenondemand"
+  spec.version       = Havenondemand::VERSION
+  spec.authors       = ["Tyler Nappy" ," Martin Zerbib"]
+  spec.email         = ["tyler.nappy@hpe.com"]
+  spec.summary       = %q{Haven OnDemand Ruby Client}
+  spec.description   = %q{}
+  spec.homepage      = "https://github.com/HP-Haven-OnDemand/havenondemand-ruby"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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_runtime_dependency "unirest"
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/lib/havenondemand.rb

@@ -0,0 +1,364 @@
+
+
+require 'Unirest'
+require 'json'
+#require 'httpclient'
+
+
+
+
+
+
+class HODError < StandardError
+
+end
+
+
+
+class HODResponse
+
+  attr_accessor :response
+
+  def initialize(response)
+    #@query=query
+
+    @response=response
+  end
+
+  def json()
+    @response.body
+  end
+
+end
+
+class HODAsyncResponse < HODResponse
+
+  attr_accessor :response
+  attr_accessor :jobID
+  def initialize(response,client)
+    #@query=query
+    @response=response
+    @client=client
+    @jobID =response.body["jobID"]
+  end
+
+  def status()
+    @client.getStatus(@jobID)
+  end
+
+  def result()
+    @client.getResult(@jobID)
+  end
+
+end
+
+
+
+class HODClient
+  @@version=1
+  @@apidefault=1
+  def initialize(url, apikey)
+    # Instance variables
+
+    @url = url
+    @apikey = apikey
+
+  end
+
+
+  def getStatus(jobID)
+    data={"apikey"=>@apikey}
+    response=Unirest.post "#{@url}/#{@@version}/job/status/#{jobID}",
+                    headers:{ "Accept" => "application/json" },
+                    parameters:data
+    return HODResponse.new(response)
+
+  end
+
+  def getResult(jobID)
+    data={"apikey"=>@apikey}
+    response=Unirest.post "#{@url}/#{@@version}/job/result/#{jobID}",
+                      headers:{ "Accept" => "application/json" },
+                      parameters:data
+    return HODResponse.new(response)
+  end
+
+  def deleteIndex(index)
+    if index.class.name=="HODIndex"
+      index=index.name
+    end
+
+    data=Hash.new
+    data[:index]=index
+
+    delete=post("deletetextindex",data)
+    confirm=delete.json()["confirm"]
+    data[:confirm]=confirm
+    delete=post("deletetextindex",data)
+    return delete
+  end
+
+  def deleteConnector(connector)
+    data=connectorUtil(connector)
+    delete=post("deleteconnector",data)
+    return delete
+  end
+
+
+  def connectorUtil(connector)
+    if index.class.name=="HODConnector"
+      connector=connector.name
+    end
+    data=Hash.new
+    data[:connector]=connector
+    return data
+  end
+
+
+  def startConnector(connector)
+    data=connectorUtil(connector)
+    return post("startconnector",data)
+  end
+
+  def retrieveConnectorConfig(connector)
+    data=connectorUtil(connector)
+    return post("retrieveconfig",data)
+  end
+
+  def connectorstatus(connector)
+    data=connectorUtil(connector)
+    return post("connectorstatus",data)
+  end
+
+  def post(handler, data=Hash.new, async=false)
+    data[:apikey]=@apikey
+    syncpath="sync"
+    if async
+      syncpath="async"
+    end
+    Unirest.timeout(30)
+    response=Unirest.post "#{@url}/#{@@version}/api/#{syncpath}/#{handler}/v#{@@apidefault}",
+                        headers:{ "Accept" => "application/json", "Content-Type" => "application/json"},
+                        parameters:data.to_json
+    if response.code == 200
+
+      if async
+        return HODAsyncResponse.new(response,self)
+      end
+      return HODResponse.new(response)
+    else
+      puts response.body
+      #puts data[:json].encoding.name
+      raise HODError.new "Error #{response.body["error"]} -- #{response.body["reason"]}"
+    end
+  end
+
+
+
+  def getIndex(name)
+    #indexes=self.listIndexes()
+
+    index=HODIndex.new(name,client:self)
+    #puts (index in indexes)
+
+  end
+
+
+
+  def createIndex(name,flavor="standard",parametric_fields=[],index_fields=[])
+    data=Hash.new
+    data[:index]=name
+    data[:flavor]=flavor
+    data[:parametric_fields]=parametric_fields
+    data[:index_fields]=index_fields
+    self.post("createtextindex",data)
+    return HODIndex.new(name,client:self)
+  end
+
+  def listIndexes()
+    r=post("listindex")
+
+    indexes=r["index"].map { |index| HODIndex.new(index["index"],index["flavor"],index["type"],client:self)}
+
+  end
+
+
+  def addDoc(doc, index)
+      self.addDocs([doc],index)
+  end
+
+  def addDocs(docs, index,async=false)
+
+
+    #  puts docs
+    #  puts docs.length
+    #jsondocs= docs.map { |doc| doc.data}
+    jsondocs=docs
+    #puts jsondocs
+    docs=Hash.new
+    docs[:documents]=jsondocs
+
+    #puts docs.to_json
+    docs=docs.to_json
+    puts docs.length
+    #puts docs
+    #docs=render :json => JSON::dump(docs)
+    data={json:docs,index:index}
+
+    return self.post("addtotextindex",data,async)
+  end
+
+end
+
+class HODConnector
+
+    attr_reader :client
+    attr_reader :name
+
+
+  def initialize(name,client=nil)
+    @name=name
+    @client=client
+  end
+
+  def create(type="web",config=Hash.new, destination="", schedule="",description="")
+    config("addtotextindex",type,config,destination,schedule,description)
+  end
+
+
+  def update(type="web",config=Hash.new, destination="", schedule="",description="")
+    config("addtotextindex",type,config,destination,schedule,description)
+  end
+
+  def config(method,type="",config="", destination="", schedule="",description="")
+    data=Hash.new
+    data[:connector]=@name
+    if type!=""
+      data[:type]=type
+    end
+    if config!=""
+      data[:config]=JSON.dump config
+    end
+    if destination!=""
+      destination={"action"=>"addtotextindex", "index" => destination }
+      data[:destination]=JSON.dump destination
+    end
+    if schedule != ""
+      data[:schedule]=JSON.dump schedule
+    end
+    data[:description]=description
+    result=@client.post(method,data)
+    puts result
+  end
+
+  def delete()
+    @client.deleteConnector(@name)
+  end
+
+  def config()
+    @client.retrieveConnectorConfig(@name)
+  end
+
+  def status()
+    @client.connectorStatus(@name)
+  end
+
+  def ==(other_object)
+    comparison_object.equal?(self) || (comparison_object.instance_of?(self.class) && @name == other_object.name)
+  end
+end
+
+
+
+
+
+class HODIndex
+
+    attr_reader :client
+    attr_reader :name
+
+
+  def initialize(name,flavor="standard",type="normal",client:nil)
+    @name=name
+
+    @client=client
+    @docs=[]
+  end
+
+    def query(text,data=Hash.new)
+      data[:database_match]=@name
+
+      data[:text]=text
+    result=@client.post("querytextindex",data)
+    result["documents"].map!{|doc| HODDoc.new(doc) }
+      return result
+    end
+   def size()
+      return @docs.length
+    end
+  def pushDoc(doc)
+    @docs.push(doc)
+
+  end
+
+  def commit(async=false)
+#		docs={document:@docs}
+#		data={json:docs.to_json,index:@name}
+#		puts docs.to_json
+
+    #r=@client.post("addtotextindex",data)
+    #@docs=[]
+    response=addDocs(@docs,async)
+    @docs=[]
+    return response
+  end
+
+  def addDoc(doc)
+    docs=Hash.new
+
+#		docs[:document]=[doc.data]
+#		data={json:docs.to_json,index:@name}
+#		@client.postasync("addtotextindex",data)
+    puts @client.addDoc(doc,@name)
+  end
+
+
+  def addDocs(docs,async=false)
+
+#		docs[:document]=[doc.data]
+#		data={json:docs.to_json,index:@name}
+#		@client.postasync("addtotextindex",data)
+
+    return @client.addDocs(docs,@name,async)
+  end
+
+  def delete()
+    clientcheck()
+    @client.deleteIndex(self)
+  end
+
+  def ==(other_object)
+    comparison_object.equal?(self) || (comparison_object.instance_of?(self.class) && @name == other_object.name)
+  end
+end
+
+
+
+class HODDoc
+
+    attr_accessor :data
+    attr_accessor :sentiment
+    attr_accessor :entities
+  def initialize(data)
+    #@query=query
+    @entities=Hash.new
+    @data=data
+  end
+
+  def to_json(options={})
+      return render :json => JSON::dump(@data)
+  end
+
+
+
+end

data/lib/havenondemand/version.rb

@@ -0,0 +1,3 @@
+module Havenondemand
+  VERSION = "1.0.0"
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: havenondemand
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Tyler Nappy
+- " Martin Zerbib"
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-10-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: unirest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: ''
+email:
+- tyler.nappy@hpe.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".DS_Store"
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/.DS_Store
+- examples/examples.rb
+- examples/testhelper.rb
+- havenondemand.gemspec
+- lib/.DS_Store
+- lib/havenondemand.rb
+- lib/havenondemand/.DS_Store
+- lib/havenondemand/version.rb
+homepage: https://github.com/HP-Haven-OnDemand/havenondemand-ruby
+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.4.6
+signing_key: 
+specification_version: 4
+summary: Haven OnDemand Ruby Client
+test_files: []