betaface 0.3.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ccac298f929a2636847ae39b9984c108836767fe
+  data.tar.gz: 35049c0416dbaba090849e2daf1dc844b2373604
+SHA512:
+  metadata.gz: c831f5d042539c1560a9f4df85affd140c9b7d1aef5743c687cbf9cd360e5debdca776002adff78d68b735f9c71277956528e3bbe85a436d05f49240e40e088d
+  data.tar.gz: 8e8191e0f1eb4892639fbdb0e4dcd7d1d2dcb30c95c038c7b09de9cccbde91bf50bec5cab36348eaf9326c7731f1eb626eb3e83263326efb21a6a8ef7657e0b8

data/README.md

@@ -0,0 +1,69 @@
+# betaface
+Betaface is the unofficial ruby Gem for the Betaface API. You can find all needed documentation about the official API at [Betaface docs](https://betafaceapi.com/wpa/index.php/documentation)
+
+## Installation
+To install using [Bundler][bundler] grab the latest stable version:
+
+```ruby
+gem 'betaface'
+```
+
+To manually install `betaface` via [Rubygems][rubygems] simply gem install:
+
+```bash
+gem install betaface
+```
+
+
+## Configuration
+
+### Put your own credentials here
+``` ruby
+require 'betaface'
+Betaface.key = "d45fd466-51e2-4701-8da8-04351c872236"
+Betaface.secret = "171e8465-f548-401d-b63b-caf0dc28df5f"
+```
+
+### alternatively, you can preconfigure the client like so
+``` ruby
+require 'betaface'
+api = Betaface::Api.new("d45fd466-51e2-4701-8da8-04351c872236","171e8465-f548-401d-b63b-caf0dc28df5f")
+```
+
+## Upload a picture
+
+```ruby
+api = Betaface::Api.new
+api.upload_image("propoints,classifiers",{url:"http://img.wennermedia.com/480-width/1444256733_tom-cruise-zoom.jpg"})
+```
+
+## Get image info
+
+```ruby
+api = Betaface::Api.new
+api.get_image_info("2bdcd1ad-47a6-45f8-ba74-86c765272422")
+```
+
+## Supported Ruby Versions
+
+This library supports and is [tested against][travis] the following Ruby
+implementations:
+
+- Ruby 2.2.0
+- Ruby 2.1.0
+- Ruby 2.0.0
+- Ruby 1.9.3
+- [JRuby][jruby]
+- [Rubinius][rubinius]
+
+## More Information
+
+There are more detailed examples in the included [examples][examples]
+
+[bundler]: http://bundler.io
+[rubygems]: http://rubygems.org
+[examples]: https://github.com/jrm2194/betaface/tree/master/examples
+
+## License
+
+(The MIT License.)

data/betaface.gemspec

@@ -0,0 +1,20 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'betaface/version'
+
+Gem::Specification.new do |s|
+  s.name                     = 'betaface'
+  s.version                  = Betaface::VERSION
+  s.date                     = '2016-06-02'
+  s.files                    = `git ls-files -z`.split("\x0")
+  s.require_paths            = ['lib']
+  s.summary                  = "Use the betaface API with Ruby!"
+  s.description              = "A ruby Gem to easily use the betaface API without having to deal with all this XLM"
+  s.authors                  = ["Jean Meyer"]
+  s.email                    = 'jean@getonce.com'
+  s.homepage                 = 'http://rubygems.org/gems/betaface'
+  s.license                  = 'MIT'
+  s.required_ruby_version    = '>= 1.9.3'
+  s.add_dependency('multi_json', '>= 1.3.0')
+  s.add_dependency('rubysl') if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
+end

data/examples/get_image_info.rb

@@ -0,0 +1,6 @@
+#!/usr/bin/ruby
+require 'betaface'
+Betaface.key = "d45fd466-51e2-4701-8da8-04351c872236"
+Betaface.secret = "171e8465-f548-401d-b63b-caf0dc28df5f"
+api = Betaface::Api.new
+p api.get_image_info("2bdcd1ad-47a6-45f8-ba74-86c765272422")

data/examples/upload_from_url.rb

@@ -0,0 +1,7 @@
+#!/usr/bin/ruby
+require 'active_support/all'
+require 'betaface'
+Betaface.key = "d45fd466-51e2-4701-8da8-04351c872236"
+Betaface.secret = "171e8465-f548-401d-b63b-caf0dc28df5f"
+api = Betaface::Api.new
+p api.upload_image("propoints,classifiers",{url:"http://img.wennermedia.com/480-width/1444256733_tom-cruise-zoom.jpg"})

data/lib/betaface.rb

@@ -0,0 +1,40 @@
+require 'net/http'
+require 'net/https'
+require 'json'
+require 'multi_json'
+
+require 'betaface/version'
+require 'betaface/util'
+require 'betaface/util/client_config'
+require 'betaface/rest/client'
+require 'betaface/rest/errors'
+require 'betaface/api'
+
+
+module Betaface
+
+  def self.key
+    @key
+  end
+
+  def self.secret 
+    @secret
+  end
+
+  def self.host
+    @host
+  end
+
+  def self.key=(key)
+    @key = key
+  end
+
+  def self.secret=(secret)
+    @secret = secret
+  end
+
+  def self.host=(host)
+    @host = host
+  end
+  
+end

data/lib/betaface/api.rb

@@ -0,0 +1,158 @@
+module Betaface
+  class Api
+    include Betaface::REST
+
+    attr_reader :client
+
+    ##
+    # Do nothing for now
+    def initialize(*args)
+      @client ||= Betaface::REST::Client.new(*args) 
+    end
+
+    #############################
+    #                           #
+    #         RESOURCES         #
+    #                           #
+    #############################
+
+
+    ##
+    # https://www.betafaceapi.com/service_json_ssl.svc/FaceInfo_Delete
+    # Delete image and faces information
+    # Note to the API dev: a REST DELETE instead of a POST is recommended
+    def face_info_delete(face_uid)
+      @client.post "/service_json_ssl.svc/FaceInfo_Delete", {face_uid:face_uid}
+    end
+
+    ##
+    # https://www.betafaceapi.com/service_json_ssl.svc/FaceInfo_New
+    # Tag new info about a face in an picture/image
+    def face_info_new(img_uid, faceinfo = {})
+      @client.post "/service_json_ssl.svc/FaceInfo_New", {img_uid:img_uid,faceinfo:faceinfo}
+    end
+
+    ##
+    # https://www.betafaceapi.com/service_json_ssl.svc/FaceInfo_SetFaceImagePoints
+    def face_info_set_face_image_points(face_uid, points = [])
+      @client.post "/service_json_ssl.svc/FaceInfo_SetFaceImagePoints", {face_uid:face_uid,points:points}
+    end
+
+    ##
+    # https://www.betafaceapi.com/service_json_ssl.svc/FaceInfo_SetPoints
+    def face_info_set_points(face_uid, points = [])
+      @client.post "/service_json_ssl.svc/FaceInfo_SetPoints", {face_uid:face_uid,points:points}
+    end
+
+    ##
+    # https://www.betafaceapi.com/service_json_ssl.svc/FaceInfo_SetTags
+    def face_info_set_tags(face_uid, tags = [])
+      @client.post "/service_json_ssl.svc/FaceInfo_SetTags", {face_uid:face_uid,tags:tags}
+    end
+
+    ##
+    # https://www.betafaceapi.com/service_json_ssl.svc/FaceInfo_Update
+    # Update info about a face in an picture/image
+    def face_info_update(face_uid, faceinfo = {})
+      @client.post "/service_json_ssl.svc/FaceInfo_Update", {face_uid:face_uid,faceinfo:faceinfo}
+    end
+
+    ##
+    # https://www.betafaceapi.com/service_json_ssl.svc/GetFaceImage
+    # Retrieve cropped face image and points coordinates in cropped face image coordinates
+    def get_face_image(face_uid)
+      @client.post "/service_json_ssl.svc/GetFaceImage", {face_uid:face_uid}
+    end
+
+    ##
+    # https://www.betafaceapi.com/service_json_ssl.svc/GetImageFileInfo
+    # Retrieve image and faces information or processing status using image file SHA-256 hash code
+    def get_image_file_info(img_checksum)
+      @client.post "/service_json_ssl.svc/GetImageFileInfo", {img_checksum:img_checksum}
+    end
+
+    ##
+    # https://www.betafaceapi.com/service_json_ssl.svc/GetImageInfo
+    # Retrieve image and faces information or processing status 
+    def get_image_info(img_uid)
+      @client.post "/service_json_ssl.svc/GetImageInfo", {img_uid:img_uid}
+    end
+
+    ##
+    # https://www.betafaceapi.com/service_json_ssl.svc/GetRecognizeResult
+    # Get results of recognition request or processing status 
+    def get_recognize_result(recognize_uid)
+      @client.post "/service_json_ssl.svc/GetRecognizeResult", {recognize_uid:recognize_uid}
+    end
+
+    ##
+    # https://www.betafaceapi.com/service_json_ssl.svc/GetTransformResult
+    # Get results of transform request or processing status
+    def get_transform_result(transform_uid)
+      @client.post "/service_json_ssl.svc/GetTransformResult", {transform_uid:transform_uid}
+    end
+
+    ##
+    # https://www.betafaceapi.com/service_json_ssl.svc/GetVerifyResult
+    def get_verify_result(verify_string)
+      @client.post "/service_json_ssl.svc/GetVerifyResult", {verify_string:verify_string}
+    end
+
+    ##
+    # https://www.betafaceapi.com/service_json_ssl.svc/RecognizeFaces
+    # Execute recognition request for each of face ids and specified list of targets 
+    # (comma separated list either of face ids, or persons and namespaces as name@namespace.com or all@namespace.com)
+    def recognize_faces(faces_uids, targets, params)
+      @client.post "/service_json_ssl.svc/RecognizeFaces", {faces_uids:faces_uids,targets:targets,parameters:params}
+    end
+
+    ##
+    # https://www.betafaceapi.com/service_json_ssl.svc/SetPerson
+    # Assign person name (John Doe@mynamespace.com) to one or more face ids
+    def set_person(faces_uid, person_id)
+      @client.post "/service_json_ssl.svc/SetPerson", {faces_uids:faces_uids,person_id:person_id}
+    end
+
+    ##
+    # Assign person name (John Doe@mynamespace.com) to one or more face ids
+    # https://www.betafaceapi.com/service_json_ssl.svc/TransformFaces
+    def transform_faces(action, faces_points, faces_uids, params)
+      @client.post "/service_json_ssl.svc/TransformFaces", {faces_uids:faces_uids,action:action,faces_points:faces_points,parameters:params}
+    end
+
+    ##
+    # https://www.betafaceapi.com/service_json_ssl.svc/UploadImage
+    # Upload image url or base64 encoded string
+    # detection flags: propoints,classifiers,extended
+    # TODO Upload image file
+    def upload_image(detection_flags, image = {})
+      params = {detection_flags:detection_flags}
+      params[:url] = image[:url] if image[:url].present?
+      params[:original_filename] = image[:url].split("/")[-1] if image[:url].present? and image[:original_filename].blank?
+      params[:image_base64] = image[:base64] if image[:base64].present?
+      @client.post "/service_json_ssl.svc/UploadImage", params
+    end
+
+    ##
+    # https://www.betafaceapi.com/service_json_ssl.svc/UploadNewImage_File
+    # detection flags: propoints,classifiers,extended
+    # Upload image file as Base64Binary encoded string
+    # TODO Need to be fixed on the API Server
+    def upload_new_image_file(detection_flags, image = {})
+      @client.post "/service_json_ssl.svc/UploadNewImage_File", {detection_flags:detection_flags,imagefile_data:image[:data],original_filename:image[:original_filename]}
+    end
+
+    ##
+    # https://www.betafaceapi.com/service_json_ssl.svc/UploadNewImage_Url
+    # detection flags: propoints,classifiers,extended
+    # Upload image url
+    # TODO Need to be fixed on the API Server
+    def upload_new_image_url(detection_flags, image = {})
+      params = {detection_flags:detection_flags}
+      params[:url] = image[:url] if image[:url].present?
+      params[:original_filename] = image[:url].split("/")[-1] if image[:url].present? and image[:original_filename].blank?
+      @client.post "/service_json_ssl.svc/UploadNewImage_Url", params
+    end
+
+  end
+end

data/lib/betaface/rest/client.rb

@@ -0,0 +1,86 @@
+module Betaface
+  module REST
+    class Client
+      include Betaface::Util
+
+      HTTP_HEADERS = {
+          'Content-Type' => 'application/json',
+          'Accept-Charset' => 'utf-8',
+          'User-Agent' => "betaface/#{Betaface::VERSION}" \
+                        " (#{RUBY_ENGINE}/#{RUBY_PLATFORM}" \
+                        " #{RUBY_VERSION}-p#{RUBY_PATCHLEVEL})"
+      }
+
+      attr_reader :last_request, :last_response
+
+      ##
+      # Instantiate the Client with a key/secret if not set before
+      # Just call new if Betaface.key and Betaface.secret have been init
+      # Last argument is a hash of options
+      def initialize(*args)
+        @config = Betaface::Util::ClientConfig.new 
+        @key = args[0] || Betaface.key
+        @secret = args[1] || Betaface.secret
+        if @key.nil? || @secret.nil?
+          raise ArgumentError, 'Key and Secret are required'
+        end
+      end
+
+      # let's define all rest calls even though betaface currently supports only POST
+      # Maybe they'll adopt some RESTful best practice soon :)
+      [:get, :put, :post, :delete].each do |method|
+        method_class = Net::HTTP.const_get method.to_s.capitalize
+        define_method method do |path, *args|
+          payload = args[0]
+          payload ||= {} 
+          @config.host.chomp!("/") 
+          path = ((path[0] == "/") ? path : ("/" + path).to_s)
+          uri = URI(@config.host + path)
+          request = method_class.new(uri, HTTP_HEADERS)
+          payload[:api_secret] = @secret
+          payload[:api_key] = @key
+          request.body = payload.to_json if [:post, :put].include?(method)
+          connect_and_send(request)
+        end
+      end
+
+      protected
+
+      ##
+      # Send an HTTP request using the cached <tt>@connection</tt> object and
+      # return the JSON response body parsed into a hash. Also save the raw
+      # Net::HTTP::Request and Net::HTTP::Response objects as
+      # <tt>@last_request</tt> and <tt>@last_response</tt> to allow for
+      # inspection later.
+      def connect_and_send(request) 
+        @last_request = request
+        retries_left = @config.retry_limit
+        begin
+          http = Net::HTTP.new(request.uri.host, request.uri.port)
+          http.use_ssl = true if request.uri.scheme == "https"
+          response = http.start do |h| 
+            h.request(request)
+          end
+          @last_response = response
+          if response.kind_of? Net::HTTPServerError
+            raise Betaface::REST::ServerError
+          end
+        rescue
+          raise if request.class == Net::HTTP::Post
+          if retries_left > 0 then retries_left -= 1; retry else raise end
+        end
+        if response.body and !response.body.empty?
+          object = MultiJson.load response.body
+        elsif response.kind_of? Net::HTTPBadRequest
+          object = { message: 'Bad request', code: 400 }
+        end
+
+        if response.kind_of? Net::HTTPClientError
+          raise Betaface::REST::RequestError.new object['message'], object['code']
+        end
+        object
+      end
+    end
+  end
+end
+

data/lib/betaface/rest/errors.rb

@@ -0,0 +1,14 @@
+module Betaface
+  module REST
+    class ServerError < StandardError; end
+
+    class RequestError < StandardError
+      attr_reader :code
+
+      def initialize(message, code=nil);
+        super message
+        @code = code
+      end
+    end
+  end
+end

data/lib/betaface/util.rb

@@ -0,0 +1,7 @@
+module Betaface
+  module Util
+    def url_encode(hash)
+      hash.to_a.map {|p| p.map {|e| CGI.escape get_string(e)}.join '='}.join '&'
+    end
+  end
+end

data/lib/betaface/util/client_config.rb

@@ -0,0 +1,23 @@
+module Betaface
+  module Util
+    class ClientConfig
+      DEFAULTS = {
+          host: 'https://www.betafaceapi.com/',
+          port: 443,
+          use_ssl: true,
+          timeout: 30,
+          retry_limit: 1
+      }
+
+      DEFAULTS.each_key do |attribute|
+        attr_accessor attribute
+      end
+
+      def initialize(opts={})
+        DEFAULTS.each do |attribute, value|
+          send("#{attribute}=".to_sym, opts.fetch(attribute, value))
+        end
+      end
+    end
+  end
+end

data/lib/betaface/version.rb

@@ -0,0 +1,3 @@
+module Betaface
+  VERSION = '0.3.1'
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: betaface
+version: !ruby/object:Gem::Version
+  version: 0.3.1
+platform: ruby
+authors:
+- Jean Meyer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-06-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+description: A ruby Gem to easily use the betaface API without having to deal with
+  all this XLM
+email: jean@getonce.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- betaface.gemspec
+- examples/get_image_info.rb
+- examples/upload_from_url.rb
+- lib/betaface.rb
+- lib/betaface/api.rb
+- lib/betaface/rest/client.rb
+- lib/betaface/rest/errors.rb
+- lib/betaface/util.rb
+- lib/betaface/util/client_config.rb
+- lib/betaface/version.rb
+homepage: http://rubygems.org/gems/betaface
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Use the betaface API with Ruby!
+test_files: []
+has_rdoc: