mirador 0.1.1 → 0.2.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZWEzZDk2NDYzYTdmMWVlZDVkMjQwNDliMDhkNDVjMjk1NzQ5ODAwZA==
+    ZDU2NmFkMWU5MjZhZGUwNWFmYWE5OWQyZjExZTI3YzhjOWNiODk2Mg==
   data.tar.gz: !binary |-
-    ZjJhZjAzNWVjYWM5ODE0NWZiNDk3OTc4ZmZjMjA2MzFlNzdhMWIxNw==
+    NTI5MzMwZjhiZDAwYmVkMzJkYjZlODE5MjhmYTUwMDI0ZTBmYjA5Nw==
 SHA512:
   metadata.gz: !binary |-
-    OTk3ZmI2YjliNDU0NzJjNGU5M2JjMjQ3NTRhMzdlMTY3MDg4ODQ5NWQxMmJl
-    MzI0NGQ3NGNjNzgzZGI3NmJiNjY4MzUyYTM2NTVjYWIyZWRjZDJhMTg2YmVh
-    MTViNzhmNWViNzg1NWQ0NTkwMzJkNWUzYTAwMDZmYzMxMTBlOTE=
+    ZDkzNWZhNzRhYjBmNGU0MWI2NjJmZTljZmMyYzRmMjM0ZWUxYjA4M2M4MGI2
+    NjhlODljNjg1NDNmNTQ2MjVkZDQxMGQ0NDY5MWZiZjUxZTMxYzhmOTg2MGMz
+    YzRjNmZlZGEyYzI3MTJmZDYwMjA3OTg0MzgyNGNiYTk5MGE2NWY=
   data.tar.gz: !binary |-
-    YTQ5OGViY2VjMTk4NWM5MDEwMjVkZGMzN2Y5MDBhNzkwNmYzNWEwZmY4YTVh
-    MjdlYTQxZmEzMzVjZTU3OWNjMDdlOTMyYzQ0ZDc4N2YxODhiMmQ5MDJlMTFk
-    OWEyNzZhZjljZTJjMWQ5NDE3MTNmOTUzMDQ0ZGE2ODAzYmJhNjI=
+    ZjFkYzQ2YmI1MjBkMTJhNGM3Y2IyZjM5MWU3YzhmOWIwODBjZDQwZGMzNDkw
+    YTNkZGExOGQ3Y2YzMjljOThkNDBlYTBjZmJlNmIzNjM2NDk4OTE3ZGNkMmY3
+    NDA2OGRmMzc3YTBhNDhmYjZiMzg1YTdhNTFmMWNhZTBlOWZkNDg=

data/lib/mirador.rb

@@ -1,396 +1,12 @@
-require 'httparty'
-require 'base64'
+require 'mirador/result'
+require 'mirador/error'
+require 'mirador/processing'
+require 'mirador/formatter'
+require 'mirador/client'
 
 module Mirador
 
-  class ApiError < StandardError
-  end
-
-  class ResultList
-    include Enumerable
-
-    def initialize(items=[])
-      @items = {}
-
-      items.each do |x|
-        @items[x.id] = x
-      end
-    end
-
-    def <<(item)
-      @items[item.id] = item
-    end
-
-    def [](key)
-      if key.is_a? Integer and not @items.has_key? key
-        @items.values[key]
-      else
-        @items[key.to_s]
-      end
-    end
-
-    def to_a
-      @items.values
-    end
-
-    def length
-      @items.values.length
-    end
-
-    def update other
-      @items.update(other)
-    end
-
-    def to_h
-      @items
-    end
-
-    def to_json
-      @items.to_json
-    end
-
-    def each &block
-      if block.arity == 1
-        @items.values.each do |x|
-          block.call(x)
-        end
-      else
-        @items.each do |k, v|
-          block.call(k, v)
-        end
-      end
-    end
-
-    def self.parse_results res
-
-      output = {}
-      res.each do |x|
-        r = Result.new(x)
-        output[r.id] = r
-      end
-
-      output
-    end
-
-  end
-
-  class Result
-    attr_accessor :id, :safe, :value, :error
-
-    def initialize data
-
-      if data.has_key? 'errors'
-        @error = data['errors']
-        return
-      end
-
-      @id = data['id']
-      @safe = data['result']['safe']
-      @value = data['result']['value']
-
-    end
-
-    def to_h
-      {
-        id: @id,
-        safe: @safe,
-        value: @value,
-      }
-    end
-
-    def to_json
-      as_h = self.to_h
-
-      if as_h.respond_to? :to_json
-        as_h.to_json
-      else
-        nil
-      end
-    end
-
-    def failed?
-      @error != nil
-    end
-
-    def to_s
-      "<Mirador::Result; id: #{ @id }; safe: #{ @safe }; value: #{ @value }/>"
-    end
-
-    def name
-      @id
-    end
-
-  end
-
-  class Client
-    include HTTParty
-    base_uri 'api.mirador.im'
-
-    default_timeout 20
-
-    MAX_LEN = 4
-    MAX_ID_LEN = 256
-    DATA_URI_PRE = ';base64,'
-    DATA_URI_PRELEN = 8
-
-    def initialize(api_key)
-      @options = { api_key: api_key }
-
-      if block_given?
-        @parser = Proc.new
-      else
-        @parser = nil
-      end
-
-    end
-
-    # metaprogramming extreme
-    [:url, :file, :buffer, :encoded_string, :data_uri].each do |datatype|
-      define_method("classify_#{datatype.to_s}s") do |args, params={}, &block|
-
-        if block != nil
-          old_parser = @parser
-          @parser = block
-        end
-
-
-        res = flexible_request args, params do |item|
-          fmt_items(datatype, item)
-        end
-
-        if block != nil
-          @parser = old_parser
-        end
-
-
-        res
-      end
-
-      define_method("classify_#{datatype.to_s}") do |args, params={}, &block|
-
-        if block != nil
-          old_parser = @parser
-          @parser = block
-        end
-
-        res = self.send("classify_#{datatype.to_s}s", args, params)
-
-        if @parser
-          out = if res != nil then res.values()[0] else nil end
-        else
-          out = if res != nil then res[0] else nil end
-        end
-
-        if block != nil
-          @parser = old_parser
-        end
-
-        out
-      end
-
-    end
-
-    protected
-
-    def flexible_request(args, params={}, &cb)
-      req = {}
-
-      req = (if args.is_a? Hash
-
-        Hash[args.map do |k, v|
-          process_param(k, v)
-        end]
-
-      elsif args.is_a? String
-        Hash[[process_argument(args)]]
-
-      elsif args and args.length
-        Hash[args.each_with_index.map do |a, idx|
-          process_argument(a, idx)
-        end]
-
-      elsif params
-        Hash[params.map do |k, v|
-          process_param(k, v)
-        end]
-      end)
-
-      chunked_request(req) do |item|
-        formatted = cb.call(item)
-        make_request(formatted)
-      end
-    end
-
-    def process_argument arg, idx=0
-
-      if arg.is_a?(String) 
-        if arg.length < MAX_ID_LEN
-          [arg,  arg]
-        else
-          [idx, arg]
-        end
-
-      elsif arg.respond_to?(:name) and arg.respond_to?(:read)
-
-        [arg.name, arg]
-
-      elsif arg.respond_to?(:id) and arg.respond_to?(:data)
-
-        [arg.id, arg.data]
-
-      elsif arg.is_a?(Hash)
-
-        if arg.has_key? :id and arg.has_key? :data
-          [arg[:id], arg[:data]]
-        elsif arg.has_key? 'id' and arg.has_key? 'data'
-          [arg['id'], arg['data']]
-        end
-
-      else
-        raise ApiError, "Invalid argument: #{ arg }"
-      end
-
-    end
-
-    # given a parameter passed in,
-    # assuming that its a id => data mapping, return
-    # the correct formatting/check for any fuck ups
-    # @arguments:
-    #   k - key
-    #   v - value
-    # @returns:
-    #   { k => v } pair
-    def process_param k, v
-
-      if v.is_a?(File)
-        [ k, v.read ]
-      elsif k.respond_to?(:to_s) and v.is_a?(String)
-        [ k.to_s, v ]
-      else
-        raise ApiError, "Invalid Argument: #{ k } => #{ v }"
-      end
-
-    end
-
-    # given a request and a block,
-    # call the block X number of times
-    # where X is request.length / MAX_LEN
-    def chunked_request req, &mthd
-
-      if @parser != nil
-        output = {}
-      else
-        output = ResultList.new
-      end
-
-      req.each_slice(MAX_LEN).each do |slice|
-        output.update(mthd.call(slice))
-      end
-
-      return output
-    end
-
-    # basically, transform hash h into a hash
-    # where the key-value pairs are all formatted
-    # by 'fmt-item' (should double the number of key-value
-    # pairs in the hash)
-    def fmt_items name, h
-      out = {}
-      h.each_with_index do |kv, idx|
-        out.update fmt_item(name, idx, kv[0], kv[1])
-      end
-      return out
-    end
-
-    @@name_map = {
-      file: 'image',
-      buffer: 'image',
-      raw: 'image',
-      url: 'url',
-      encoded_string: 'image',
-      data_uri: 'image',
-    }
-
-    @@formatters = {
-      url: Proc.new { |url| url },
-
-      file: Proc.new { |file|
-
-        Base64.encode64(if file.respond_to? :read
-          file.read
-        else
-          File.read(file)
-        end).gsub(/\n/, '')
-
-      },
-
-      buffer: Proc.new { |file|
-
-        Base64.encode64(file).gsub(/\n/, '')
-
-      },
-
-      raw: Proc.new { |file|
-
-        Base64.encode64(file).gsub(/\n/, '')
-
-      },
-
-      encoded_string: Proc.new { |b64str|
-        b64str.gsub(/\n/, '')
-      },
-
-      data_uri: Proc.new { |datauri|
-        datauri.sub(/^.+;base64,/, '').gsub(/\n/,'')
-      },
-
-    }
-
-    # produce a k-v mapping internal to the API,
-    # so that 'name' is the datatype: 
-    # e.g., name[idx][id], name[idx][data]
-    def fmt_item name, idx, id, data
-      formatted = @@formatters[name].call(data)
-      datatype = @@name_map[name]
-      {
-        "#{datatype}[#{idx}][id]" => id,
-        "#{datatype}[#{idx}][data]" => formatted,
-      }
-    end
-
-    # base method to actually make the request
-    def make_request params
-
-      res = self.class.post(
-        "/v1/classify",
-        {
-          body: @options.merge(params),
-          headers: {"User-Agent" => "Mirador Client v1.0/Ruby"}
-        }
-      )
-
-      k = 'results'
-
-      if res['errors']
-
-        if not res['result']
-          raise ApiError, res
-        else
-          k = 'result'
-        end
-
-      elsif not res
-        raise ApiError, "no response: #{ res.code }"
-      end
-
-      if @parser != nil 
-        return @parser.call(res[k])
-      else
-
-        return ResultList.parse_results res[k]
-      end
-    end
-
-  end
+  # do we really want anything in here?
+  # TODO: figure out
 
 end

data/lib/mirador/client.rb

@@ -0,0 +1,120 @@
+require 'httparty'
+
+module Mirador
+
+  class Client
+    include HTTParty
+    include Processing
+    include Formatting
+
+    # the number of items
+    # to actuall send in a request
+    CHUNK_SIZE = 4
+
+    base_uri 'api.mirador.im'
+    default_timeout 20
+
+    format_map(
+      url: :url,
+      default: :image,
+    )
+
+    max_key_size 369
+
+    def initialize(api_key, opt={})
+      raise AuthenticationError.new("api key required") if not api_key
+
+      @options = { api_key: api_key }
+      @parser = opt[:parser] || ResultList
+      @chunk_size = opt[:chunk_size] || CHUNK_SIZE
+    end
+
+
+    [:url, :file, :buffer, :encoded_string, :data_uri].each do |datatype|
+
+      define_method("classify_#{datatype.to_s}s") do |args, params={}|
+        flexible_request args, params do |item|
+          format_items(datatype, item)
+        end
+      end
+
+      define_method("classify_#{datatype.to_s}") do |args, params={}|
+        res = self.send("classify_#{datatype.to_s}s", args, params)
+        res and res[0]
+      end
+
+    end
+
+    protected
+
+    def flexible_request(args, params={}, &cb)
+      req = (if args.is_a? Hash
+
+        Hash[args.map do |k, v|
+          process_param(k, v)
+        end]
+
+      elsif args.is_a? String
+        Hash[[process_argument(args)]]
+
+      elsif args and args.length
+        Hash[args.each_with_index.map do |a, idx|
+          process_argument(a, idx)
+        end]
+
+      elsif params
+        Hash[params.map do |k, v|
+          process_param(k, v)
+        end]
+      end)
+
+      chunked_request(req) do |item|
+        make_request(cb.call(item))
+      end
+    end
+
+
+    # given a request and a block,
+    # call the block X number of times
+    # where X is request.length / MAX_LEN
+    def chunked_request req, &mthd
+      output = @parser.new
+
+      req.each_slice(@chunk_size).each do |slice|
+        output.update(mthd.call(slice))
+      end
+
+      return output
+    end
+
+    # base method to actually make the request
+    def make_request params
+
+      res = self.class.post(
+        "/v1/classify",
+        {
+          body: @options.merge(params),
+          headers: {"User-Agent" => "Mirador Client v1.0/Ruby"}
+        }
+      )
+
+      k = 'results'
+
+      if res['errors']
+
+        if not res['result']
+          raise ApiError, res
+        else
+          k = 'result'
+        end
+
+      elsif not res
+        raise ApiError, "no response: #{ res.code }"
+      end
+
+      return @parser.parse_results(res[k])
+    end
+
+  end
+
+end

data/lib/mirador/error.rb

@@ -0,0 +1,14 @@
+module Mirador
+
+  #TODO: add more specific errors/subclasses
+
+  class ApiError < StandardError
+  end
+
+  class RequestArgumentError < ApiError
+  end
+
+  class AuthenticationError < ApiError
+  end
+
+end

data/lib/mirador/formatter.rb

@@ -0,0 +1,101 @@
+require 'base64'
+
+module Mirador
+
+  module Formatting
+
+    @@format_map = {}
+
+    module ClassMethods
+      protected
+
+      def format_map map={}
+
+        # get the default from the map, or use 'image',
+        # which is most likely correct..
+        default = (map.delete(:default) || :image)
+
+        map.default_proc = Proc.new { |h, k|
+          h[k] = default
+        }
+
+        Formatting.class_variable_set(:@@format_map, map)
+
+      end
+
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+      Formatting.class_variable_set(:@@formatter, Formatter.new)
+    end
+
+    protected
+
+    def format_items dtype, items
+      Hash[items.each_with_index.map do |kv, idx|
+        format_item(dtype, idx, kv[0], kv[1])
+      end.flatten(1)]
+    end
+
+    private
+
+    def format_item dtype, idx, id, data
+      formatted, dt = get_format(data, dtype.to_sym)
+
+      [
+        ["#{ dt }[#{ idx }][id]", id],
+        ["#{ dt }[#{ idx }][data]", formatted],
+      ]
+    end
+
+    def get_format item, dtype
+      dtype = dtype.to_sym
+
+      if not @@formatter.respond_to? dtype
+        raise ApiError, "unsupported datatype: #{ dtype }"
+      end
+
+      return @@formatter.send(dtype, item), @@format_map[dtype]
+    end
+
+  end
+
+  class Formatter
+    DATA_URI_RXP = /^.+;base64,/
+
+    def url item
+      item
+    end
+
+    def buffer item
+      encode_filedata(item)
+    end
+
+    def file item
+      encode_filedata(
+        if item.respond_to? :read
+          item.read
+        else
+          File.read(item)
+        end
+      )
+    end
+
+    def encoded_string item
+      item.gsub(/\n/, '')
+    end
+
+    def data_uri item
+      item.sub(DATA_URI_RXP, '').gsub(/\n/,'')
+    end
+
+    private
+
+    def encode_filedata(data)
+      Base64.encode64(data).gsub(/\n/, '')
+    end
+
+  end
+
+end

data/lib/mirador/processing.rb

@@ -0,0 +1,80 @@
+module Mirador
+
+  module Processing
+
+    MAX_KEY_SIZE = 256
+
+    module ClassMethods
+      attr_accessor :_max_key_size
+
+      def max_key_size num
+        Processing.class_variable_set(:@@max_key_size, num)
+      end
+
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+      Processing.class_variable_set(:@@max_key_size, MAX_KEY_SIZE)
+    end
+
+    protected 
+
+    # given an argument, e.g.,
+    # an item in a *args list, 
+    # return the proper datatype-pair
+    # (to be put into a Hash)
+    def process_argument arg, idx=0
+
+      if arg.is_a?(String) 
+        if arg.length < @@max_key_size
+          [arg,  arg]
+        else
+          [idx, arg]
+        end
+
+      elsif arg.respond_to?(:name) and arg.respond_to?(:read)
+
+        [arg.name, arg]
+
+      elsif arg.respond_to?(:id) and arg.respond_to?(:data)
+
+        [arg.id, arg.data]
+
+      elsif arg.is_a?(Hash)
+
+        if arg.has_key? :id and arg.has_key? :data
+          [arg[:id], arg[:data]]
+        elsif arg.has_key? 'id' and arg.has_key? 'data'
+          [arg['id'], arg['data']]
+        end
+
+      else
+        raise ApiError, "Invalid argument: #{ arg }"
+      end
+
+    end
+
+    # given a parameter passed in,
+    # assuming that its a id => data mapping, return
+    # the correct formatting/check for any fuck ups
+    # @arguments:
+    #   k - key
+    #   v - value
+    # @returns:
+    #   { k => v } pair
+    def process_param k, v
+
+      if v.is_a?(File)
+        [ k, v.read ]
+      elsif k.respond_to?(:to_s) and v.is_a?(String)
+        [ k.to_s, v ]
+      else
+        raise ApiError, "Invalid Argument: #{ k } => #{ v }"
+      end
+
+    end
+
+  end
+
+end

data/lib/mirador/result.rb

@@ -0,0 +1,119 @@
+module Mirador
+
+  class ResultList
+    include Enumerable
+
+    def initialize(items=[])
+      @items = {}
+
+      items.each do |x|
+        @items[x.id] = x
+      end
+    end
+
+    def <<(item)
+      @items[item.id] = item
+    end
+
+    def [](key)
+      if key.is_a? Integer and not @items.has_key? key
+        @items.values[key]
+      else
+        @items[key.to_s]
+      end
+    end
+
+    def to_a
+      @items.values
+    end
+
+    def length
+      @items.values.length
+    end
+
+    def update other
+      @items.update(other)
+    end
+
+    def to_h
+      @items
+    end
+
+    def to_json
+      @items.to_json
+    end
+
+    def each &block
+      if block.arity == 1
+        @items.values.each do |x|
+          block.call(x)
+        end
+      else
+        @items.each do |k, v|
+          block.call(k, v)
+        end
+      end
+    end
+
+    def self.parse_results res
+
+      output = {}
+      res.each do |x|
+        r = Result.new(x)
+        output[r.id] = r
+      end
+
+      output
+    end
+
+  end
+
+  class Result
+    attr_accessor :id, :safe, :value, :error
+
+    def initialize data
+
+      if data.has_key? 'errors'
+        @error = data['errors']
+        return
+      end
+
+      @id = data['id']
+      @safe = data['result']['safe']
+      @value = data['result']['value']
+
+    end
+
+    def to_h
+      {
+        id: @id,
+        safe: @safe,
+        value: @value,
+      }
+    end
+
+    def to_json
+      as_h = self.to_h
+
+      if as_h.respond_to? :to_json
+        as_h.to_json
+      else
+        nil
+      end
+    end
+
+    def failed?
+      @error != nil
+    end
+
+    def to_s
+      "<Mirador::Result; id: #{ @id }; safe: #{ @safe }; value: #{ @value }/>"
+    end
+
+    def name
+      @id
+    end
+
+  end
+
+end

data/lib/mirador/version.rb

@@ -1,3 +1,3 @@
 module Mirador
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/test/test_mirador.rb

@@ -2,6 +2,29 @@ require 'test/unit'
 require './lib/mirador'
 require 'base64'
 
+class CustomTestParser
+
+  class << self
+
+    def parse_results res_hash
+      # essentially a no-op
+      res_hash
+    end
+  end
+
+  attr_accessor :results
+
+  def update partials
+    @results ||= []
+    @results += partials
+  end
+
+  def [](x)
+    return (@results ||= [])[x]
+  end
+
+end
+
 class MiradorTest < Test::Unit::TestCase
 
   dirname = File.dirname(__FILE__)
@@ -72,6 +95,12 @@ class MiradorTest < Test::Unit::TestCase
 
   end
 
+  def test_custom_parser
+    mc = Mirador::Client.new(ENV['MIRADOR_API_KEY'], parser: CustomTestParser)
+    res = mc.classify_url(NSFW_URL)
+    assert res.is_a?(Hash)
+  end
+
   def test_hash_call
 
     res = MM.classify_urls(nsfw: NSFW_URL, sfw: SFW_URL)
@@ -159,40 +188,6 @@ class MiradorTest < Test::Unit::TestCase
 
   end
 
-  def test_switch_parser 
-
-    res = MM.classify_url 'http://static.mirador.im/test/nsfw.jpg' do |results|
-
-      r = Hash[results.map do |x|
-        [x['id'], x['result']]
-      end]
-
-      r
-    end
-
-    assert res.is_a?(Hash)
-
-    res_norm = MM.classify_url 'http://static.mirador.im/test/sfw.jpg'
-
-    assert (not res_norm.is_a?(Hash))
-
-  end
-
-  def test_multiple_custom_parse
-
-    res = MM.classify_urls('http://static.mirador.im/test/nsfw.jpg', 'http://static.mirador.im/test/sfw.jpg') do |results|
-
-      r = Hash[results.map do |x|
-        [x['id'], x['result']]
-      end]
-
-      r
-    end
-
-    assert res.is_a?(Hash)
-    assert res.has_key?('http://static.mirador.im/test/nsfw.jpg')
-
-  end
 
   def test_item_error
 
@@ -205,33 +200,4 @@ class MiradorTest < Test::Unit::TestCase
 
   end
 
-  def test_custom_parser
-
-    mc = Mirador::Client.new ENV['MIRADOR_API_KEY'] do |results|
-
-      res = Hash[results.map do |x|
-        r = x['result']
-
-        [x['id'], {
-          id: x['id'],
-          breast: r['breast4'],
-          penis: r['penis4'],
-          vagina: r['vagina4'],
-          butt: r['butt4'],
-        }]
-
-      end]
-
-      res
-    end
-
-    res = mc.classify_url 'http://static.mirador.im/test/nsfw.jpg'
-
-    assert res.is_a?(Hash)
-
-    assert res[:breast]
-    assert res[:penis]
-
-  end
-
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mirador
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Nick Jacob
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-11 00:00:00.000000000 Z
+date: 2014-08-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -46,6 +46,11 @@ files:
 - bin/mirador-client
 - examples/sinatra-example.rb
 - lib/mirador.rb
+- lib/mirador/client.rb
+- lib/mirador/error.rb
+- lib/mirador/formatter.rb
+- lib/mirador/processing.rb
+- lib/mirador/result.rb
 - lib/mirador/version.rb
 - mirador.gemspec
 - test/images/nsfw.jpg