levdon 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 61b634c08e78823b483f945704724721b32f52fc
-  data.tar.gz: 4a481f533a47d9e78fc6678536882d30334b2237
+  metadata.gz: f644b9bcbe5fcd9e5a453bae0b8a0e34c9da18f5
+  data.tar.gz: 831a339cec878dc9266c50476d9d36c623f5d677
 SHA512:
-  metadata.gz: 4a5fef5c1ddb5ee772b2d4a7082e1a3867e61863c89ab709d8770fa0eedc189dfc9d21fe7e4fb6422446fe24449f119d99b5c329b17824a77e3503ce087b15ee
-  data.tar.gz: 955b51cf623e9ac600cdd339f05466bd434045c5080c7a349a471d01c496cbcf19b739dc8cc87f55a8a6825146b6f879eda8d7ee84f9b76a846d9552d272f23b
+  metadata.gz: 2a4baebf126b1b294c46ac94db7abed58ead303dfa9ca4df11179c4f3304c234ac947a6e1be89302880771790f1cc0905c2e4b881c0097345464732204ee4bf7
+  data.tar.gz: 15a5682baca2fc30062b2d01d8d82e48fe71d4d14f74df9f357ca7c5506039a58cf4d58db5d57b92e21b6ee696ed74ed446839bd632e8341f270077fd4d1e6b6

data/denoise.rb

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require 'levdon'
+
+if(ARGV.length == 0)
+  puts "standerdize script"
+  puts " => script [image directory]"
+else
+  Levdon::standardize(ARGV[0])
+end

data/denoise.sh

@@ -0,0 +1,3 @@
+
+bundle exec ruby denoise.rb $1
+

data/example1.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+
+require 'levdon'
+
+# Account is not necessary during for free version.
+ACCESS_TOKEN  = "TODO: specify your API key."
+TARGET_PATH   = "/Users/johndoe/Desktop/Unknown.jpeg"
+
+api = Levdon.new()
+state = api.start(ACCESS_TOKEN)
+if state[:error]
+  puts state[:error]
+else
+
+  res = api.predict({:target=>TARGET_PATH})
+  if res[:error]
+    puts res[:error]
+  else
+    puts res[:results]
+  end
+
+end
+api.close()
+

data/example1.sh

@@ -0,0 +1 @@
+bundle exec ruby example1.rb

data/example2.rb

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+
+require 'levdon'
+
+# Account is not necessary during for free version.
+ACCESS_TOKEN      = "TODO: specify your API key."
+TARGET_PATH       = "/Users/johndoe/Desktop/data/examples"
+
+api = Levdon.new()
+api.option({
+  :CLASS    => [:CLASS_ADULT],
+  :PARALLEL => 32
+})
+
+api.async_start(ACCESS_TOKEN) {|state|
+  if(state[:error])
+    puts state[:error]
+  else
+    Levdon.find_image(TARGET_PATH,{:no_check=>true}) {|obj|
+      path    = obj[:source_path]
+      while(api.queue_size() > 32*4)
+        api.poll()
+        sleep(0.01)
+      end
+      
+      api.async_predict({:target => path}) {|res|
+        if res[:error]
+          puts res[:error]
+        else
+          result = res[:results]
+          puts "Score: "+(result[:CLASS_ADULT]*100).to_i.to_s + " : " + path
+        end
+      }
+    }
+    
+    while(api.queue_size()!=0)
+      api.poll()
+      sleep(0.01)
+    end
+    
+  end
+}
+api.close()
+

data/example2.sh

@@ -0,0 +1 @@
+bundle exec ruby example2.rb

data/lib/levdon/version.rb

@@ -1,3 +1,3 @@
 module Levdon
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/lib/levdon.rb

@@ -33,7 +33,7 @@ module Levdon
   }
   
   ONTOLOGY_REV_LIST = {}
-  ONTOLOGY_LIST.map{|k,v| ONTOLOGY_REV_LIST[v[:key]] = k }
+  ONTOLOGY_LIST.each{|k,v| ONTOLOGY_REV_LIST[v[:key]] = k }
   
   class NonBlockLineStream
     def initialize(input_stream, output_stream)
@@ -555,67 +555,60 @@ module Levdon
       @ontologies = [:CLASS_ADULT]
     end
   
-    
-    def async_start(access_token,&block)
-      @access_token = access_token
-      @workers = @request_cluster_num.times.map{
-        Worker.new{|*args|
-          ret   = nil
-          error = nil
-          user_object = nil
+    def _predict_impl(parameter)
+      ret   = nil
+      error = nil
+      
+      f             = parameter[:target]
+      request_id    = parameter[:request_id]
+      ontologies    = parameter[:ontologies]
+      access_token  = parameter[:access_token]
+      url           = URI.parse(API_URL)
+      
+      options       = {}
+      options['ontologies'] = []
+      error = "Class is not specified." if ontologies.length == 0
+      ontologies.each{|key|
+        obj = ONTOLOGY_LIST[key]
+        unless obj
+          error = "Invalid key => " + key.to_s 
+          break
+        end
+        unless obj[:available]
+          error = key.to_s + " class is not available.\n Reason => #{obj[:desc]}" 
+          break
+        end
+        options['ontologies'] += [obj[:key]]
+      }
+      if(!error)
+        stream = load(f)
+        if(stream)
+          io = nil
           begin
-            parameter   = args[0]
-            f           = parameter[:target]
-            request_id  = parameter[:request_id]
-            ontologies  = parameter[:ontologies]
-            url         = URI.parse(API_URL)
-            
-            options     = {}
-            options['ontologies'] = []
-            error = "Class is not specified." if ontologies.length == 0
-            ontologies.each{|key|
-              obj = ONTOLOGY_LIST[key]
-              unless obj
-                error = "Invalid key => " + key.to_s 
-                break
-              end
-              unless obj[:available]
-                error = key.to_s + " class is not available.\n Reason => #{obj[:desc]}" 
-                break
-              end
-              options['ontologies'] += [obj[:key]]
-            }
-            if(!error)
-              stream = load(f)
-              if(stream)
-                  io = StringIO.new(Levdon.prob_resize(stream))
-                  req = Net::HTTP::Post::Multipart.new url.path,
-                    "api_version"   => API_VERSION,
-                    "upload"        => UploadIO.new(io, "image/jpeg", "image.jpg"),
-                    "request_id"    => request_id,
-                    "access_token"  => access_token,
-                    "constant_id"   => APPLICATION_ID,
-                    "options"       => JSON.generate(options)
-            
-                  n = Net::HTTP.new(url.host, url.port) 
-                  n.use_ssl = ENABLE_SSL
-            
-                  res = n.start {|http| http.request(req) }
-                
-                  j = JSON.parse(res.body)
-                  if(res.code == '200' and j['results'])
-                    # TODO: data struct problem
-                    ret = {}
-                    j['results'].each{|k,v|
-                      ret[ONTOLOGY_REV_LIST[k]] = v
-                    }
-                  else
-                    ret = nil
-                    error = j['desc']
-                  end
-              else
-                error = "Could not read a '#{f.to_s}'."
-              end
+            io = StringIO.new(Levdon.prob_resize(stream))
+            req = Net::HTTP::Post::Multipart.new url.path,
+              "api_version"   => API_VERSION,
+              "upload"        => UploadIO.new(io, "image/jpeg", "image.jpg"),
+              "request_id"    => request_id,
+              "access_token"  => access_token,
+              "constant_id"   => APPLICATION_ID,
+              "options"       => JSON.generate(options)
+      
+            n = Net::HTTP.new(url.host, url.port) 
+            n.use_ssl = ENABLE_SSL
+      
+            res = n.start {|http| http.request(req) }
+          
+            j = JSON.parse(res.body)
+            if(res.code == '200' and j['results'])
+              # TODO: data struct problem
+              ret = {}
+              j['results'].each{|k,v|
+                ret[ONTOLOGY_REV_LIST[k]] = v
+              }
+            else
+              ret = nil
+              error = j['desc']
             end
           rescue => e
             error = ""
@@ -636,6 +629,31 @@ module Levdon
               end
             end
           end
+        else
+          error = "Could not read a '#{f.to_s}'."
+        end
+      end
+      return {:error=>error,:result=>ret}
+    end
+    
+    def async_start(access_token,&block)
+      @access_token = access_token
+      @workers = @request_cluster_num.times.map{
+        Worker.new{|*args|
+          ret   = nil
+          error = nil
+          begin
+            parameter   = args[0]
+            parameter[:access_token] = access_token
+            obj = _predict_impl(parameter)
+            ret = obj[:result]
+            error = obj[:error]
+          rescue => e
+            error = ""
+            error += e.class.to_s + "\n"
+            error += e.message.to_s + "\n"
+            error += e.backtrace.to_s + "\n"
+          end
           
           {:results => ret, :error => error,:parameter => parameter}
         }
@@ -658,14 +676,8 @@ module Levdon
     end
     
     def start(access_token)
-      ret = nil
-      async_start(access_token){|e|
-        ret = e
-      }
-      while(ret == nil)
-        sleep(0.01)
-      end
-      ret
+      @access_token = access_token
+      return {:erorr => nil}
     end
   
     def option(obj)
@@ -686,9 +698,7 @@ module Levdon
           # from network
           return open(any).read
         else
-          # TODO File path checker
-          if(any.length < 1024)
-            # from file
+          if File::ftype(any) == "file"
             return File.open(any).read # File IO
           else
             # from memory
@@ -764,33 +774,21 @@ module Levdon
       raise "required key: target. Specify a file path or URL or data." unless(parameter[:target])
       parameter[:request_id] = SecureRandom.uuid.gsub("-","")
       parameter[:ontologies] = @ontologies
-      enqueue(parameter)
+      parameter[:access_token] = @access_token
+      
+      ret   = nil
+      error = nil
       begin
-        time = Time.new
-        loop {
-          if(Time.new - time > @timeout)
-            puts ("Timeout")
-            break
-          end
-          result = nil
-          @workers.each(&:poll)
-          @workers.map(&:nonblock_read_from_child).each_with_index{|ret,i|
-            result = ret
-            break if(ret)
-          }
-          if(result)
-            return result
-          else
-            sleep(0.01)
-          end
-        }
+        obj         = _predict_impl(parameter)
+        ret         = obj[:result]
+        error       = obj[:error]
       rescue => e
-        puts "Predict error"
-        puts e.class
-        puts e.message
-        puts e.backtrace
+        error = ""
+        error += e.class.to_s + "\n"
+        error += e.message.to_s + "\n"
+        error += e.backtrace.to_s + "\n"
       end
-      return nil
+      return {:results => ret, :error => error,:parameter => parameter}
     end
   
   end

data/test.rb

@@ -0,0 +1,83 @@
+#!/usr/bin/env ruby
+
+require 'levdon'
+
+# Account is not necessary during for free version.
+APIKEY      = ENV['EATER_ACCESS_TOKEN']
+TARGET_PATH = "/Users/johndoe/Desktop/data/test_data"
+
+USE_SYNC = true
+if(USE_SYNC)
+  api = Levdon.new()
+  api.option({:CLASS    => [:CLASS_ADULT]})
+  state = api.start(APIKEY)
+  if(state[:error])
+    puts state[:error]
+  else
+    Levdon.find_image(TARGET_PATH,{:no_check=>true}) {|obj|
+      path    = obj[:source_path]
+      res     = api.predict({:target => path})
+      
+      if res[:error]
+        puts res[:error]
+      else
+        result = res[:results]
+        score = result[:CLASS_ADULT]
+        sscore1 = (( (score * 10000).to_i)/100).to_s.rjust(5, " ")+"%"
+        sscore2 = (score * 10000).to_i.to_s.rjust(5, "0")
+        puts "Score: "+sscore1 + " : " + path
+      
+        dst_dirname     = File.dirname(path)
+        FileUtils.mv(path,File.join(dst_dirname,"CLASS_ADULT_"+sscore2+"_"+SecureRandom.uuid+"."+path.split(".")[-1]))
+      end
+      
+    }
+  end
+  api.close()
+else
+  api = Levdon.new()
+  api.option({
+    :CLASS    => [:CLASS_ADULT],
+    :PARALLEL => 32
+  })
+
+  api.async_start(APIKEY) {|state|
+    if(state[:error])
+      puts state[:error]
+    else
+      Levdon.find_image(TARGET_PATH,{:no_check=>true}) {|obj|
+        path    = obj[:source_path]
+        #next if(File.basename(path).index("CLASS_ADULT_") == 0)
+        while(api.queue_size() > 32*4)
+          api.poll()
+          sleep(0.01)
+        end
+      
+        api.async_predict({:target => path}) {|res|
+          if res[:error]
+            puts res[:error]
+          else
+            result = res[:results]
+            score = result[:CLASS_ADULT]
+            sscore1 = (( (score * 10000).to_i)/100).to_s.rjust(5, " ")+"%"
+            sscore2 = (score * 10000).to_i.to_s.rjust(5, "0")
+            puts "Score: "+sscore1 + " : " + path
+          
+            dst_dirname     = File.dirname(path)
+            FileUtils.mv(path,File.join(dst_dirname,"CLASS_ADULT_"+sscore2+"_"+SecureRandom.uuid+"."+path.split(".")[-1]))
+          
+          end
+        }
+      }
+    
+      while(api.queue_size()!=0)
+        api.poll()
+        sleep(0.01)
+      end
+    
+    end
+  }
+  api.close()
+
+end
+

data/test.sh

@@ -0,0 +1 @@
+bundle exec ruby test.rb

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: levdon
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Pegara, Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-05-11 00:00:00.000000000 Z
+date: 2017-05-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,9 +80,17 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- denoise.rb
+- denoise.sh
+- example1.rb
+- example1.sh
+- example2.rb
+- example2.sh
 - levdon.gemspec
 - lib/levdon.rb
 - lib/levdon/version.rb
+- test.rb
+- test.sh
 homepage: https://www.leviadon.com
 licenses:
 - MIT