levdon 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 61b634c08e78823b483f945704724721b32f52fc
+  data.tar.gz: 4a481f533a47d9e78fc6678536882d30334b2237
+SHA512:
+  metadata.gz: 4a5fef5c1ddb5ee772b2d4a7082e1a3867e61863c89ab709d8770fa0eedc189dfc9d21fe7e4fb6422446fe24449f119d99b5c329b17824a77e3503ce087b15ee
+  data.tar.gz: 955b51cf623e9ac600cdd339f05466bd434045c5080c7a349a471d01c496cbcf19b739dc8cc87f55a8a6825146b6f879eda8d7ee84f9b76a846d9552d272f23b

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Akihito Nakatsuka
+
+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,41 @@
+# Levdon
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/levdon`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'levdon'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install levdon
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/levdon.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "levdon"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/levdon.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'levdon/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "levdon"
+  spec.version       = Levdon::VERSION
+  spec.authors       = ["Pegara, Inc."]
+  spec.email         = ["info@pegara.com"]
+  spec.homepage      = "https://www.leviadon.com"
+  spec.summary       = %q{AI(DeepLearning) contents filter library for mastodon.}
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.14"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rmagick", "~> 2.16.0"
+  spec.add_development_dependency "multipart-post", "~> 2.0.0"
+end

data/lib/levdon/version.rb

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

data/lib/levdon.rb

@@ -0,0 +1,801 @@
+require "levdon/version"
+
+require "json"          # default
+require "securerandom"  # default
+require "fileutils"     # default
+require "stringio"      # default
+require "open-uri"      # default
+
+require "rmagick"                 # sudo gem install rmagick
+require "net/http/post/multipart" # sudo gem install multipart-post #https://github.com/nicksieger/multipart-post
+
+
+module Levdon
+  APPLICATION_ID  = "Levdon"
+  API_URL         = ENV['EATER_URL'] ? ENV['EATER_URL'] : "https://api.leviadon.com/upload"
+  API_VERSION     = "0.1.1"
+  ENABLE_SSL      = API_URL.index("https://") ? true : false
+  VUUID           = SecureRandom.uuid
+  
+  ONTOLOGY_LIST = {
+    :CLASS_ADULT          => { :available => true,   :key => 'adult',          :desc => '' },
+    :CLASS_VIOLENCE       => { :available => false,  :key => 'violence',       :desc => 'closed beta does not support a this class.' },
+    :CLASS_GENERAL_OBJECT => { :available => false,  :key => 'general_object', :desc => 'closed beta does not support a this class.' },
+    :CLASS_MEDICAL        => { :available => false,  :key => 'medical',        :desc => 'closed beta does not support a this class.' },
+    :CLASS_MEAL           => { :available => false,  :key => 'meal',           :desc => 'closed beta does not support a this class.' },
+    :CLASS_3D             => { :available => false,  :key => '3D',             :desc => 'closed beta does not support a this class.' },
+    :CLASS_2D             => { :available => false,  :key => '2D',             :desc => 'closed beta does not support a this class.' },
+    :CLASS_FACE           => { :available => false,  :key => 'face',           :desc => 'closed beta does not support a this class.' },
+    :CLASS_BODY           => { :available => false,  :key => 'body',           :desc => 'closed beta does not support a this class.' },
+    :CLASS_POSE           => { :available => false,  :key => 'pose',           :desc => 'closed beta does not support a this class.' },
+    :CLASS_ANIMAL         => { :available => false,  :key => 'animal',         :desc => 'closed beta does not support a this class.' },
+    :CLASS_OCR            => { :available => false,  :key => 'ocr',            :desc => 'closed beta does not support a this class.' }
+  }
+  
+  ONTOLOGY_REV_LIST = {}
+  ONTOLOGY_LIST.map{|k,v| ONTOLOGY_REV_LIST[v[:key]] = k }
+  
+  class NonBlockLineStream
+    def initialize(input_stream, output_stream)
+      @input_stream = input_stream
+      @output_stream = output_stream
+      @read_queue = []
+      @write_queue = []
+      @rlnb_buffer = ""
+    end
+  
+    def read
+      if(@read_queue.length)
+        return @read_queue.shift
+      end
+      return nil
+    end
+  
+    def write(s)
+      @write_queue.push(s)
+      begin
+        wrote_len = @output_stream.write_nonblock(@write_queue[0])
+        if(@write_queue[0].length == wrote_len)
+          @write_queue.shift
+        else
+          @write_queue[0] = @write_queue[0].slice(wrote_len,@write_queue[0].length)
+        end
+      rescue => e
+        puts "Write error"
+        puts e.class
+        puts e.message
+        puts e.backtrace
+      end
+      
+      @write_queue.length
+    end
+  
+    def poll
+      has_event = false
+      begin
+        if(@io)
+          if(@write_queue.length > 0)
+            wrote_len = @output_stream.write_nonblock(@write_queue[0])
+            if(@write_queue[0].length = wrote_len)
+              @write_queue.shift
+            else
+              @write_queue[0] = @write_queue[0].slice(wrote_len,@write_queue[0].length)
+            end
+            has_event = true
+          end
+        end
+      rescue => e
+        puts "Write error"
+        puts e.class
+        puts e.message
+        puts e.backtrace
+      end
+    
+      begin
+        stream = @input_stream.read_nonblock(8192)
+        @rlnb_buffer << stream
+        if(@rlnb_buffer.index("\n"))
+          sp = @rlnb_buffer.split("\n")
+          last = ""
+          if(sp.length > 1)
+            last = sp.pop
+          end
+          sp.each{|e|
+            @read_queue.push(e)
+          }
+          @rlnb_buffer = last
+        end
+        # while ch = @input_stream.read_nonblock(1)
+        #   @rlnb_buffer << ch
+        #   if ch == "\n" then
+        #     @read_queue.push(@rlnb_buffer)
+        #     @rlnb_buffer = ""
+        #   end
+        # end
+      rescue Errno::EAGAIN
+      rescue => e
+        puts "Read error"
+        puts e.class
+        puts e.message
+        puts e.backtrace
+      end
+      return has_event
+    end
+  end  
+
+  class Worker #http://qiita.com/yuroyoro/items/92c5bc864fa9c05127a9
+    attr_reader :pid
+
+    def initialize(&block)
+      @child_read, @parent_write = create_pipe
+      @parent_read, @child_write = create_pipe
+      @block = block
+      @io_stream = NonBlockLineStream.new(@parent_read,@parent_write)
+    end
+
+    def create_pipe
+      IO.pipe.map{|pipe| pipe.tap{|_| _.set_encoding("ASCII-8BIT", "ASCII-8BIT") } }
+    end
+  
+    def run
+      @pid = fork do
+        @parent_read.close
+        @parent_write.close
+        write_to_parent(:ready)
+        loop do
+          args = read_from_parent
+          break if args == :stop 
+          result = @block.call(*args)
+          write_object(result, @child_write)
+        end
+
+        @child_read.close
+        @child_write.close
+      end
+
+      wait_after_fork if @pid
+    end
+  
+    def execute(*msg)
+      write_to_child(msg)
+      Thread.new { read_from_child }
+    end
+  
+    def async_execute(*msg)
+      nonblock_write_to_child(msg)
+    end
+
+    def stop
+      return unless alive?
+      write_to_child(:stop)
+      Process.wait(@pid)
+    end
+
+    def alive?
+      Process.kill(0, @pid)
+      true
+    rescue Errno::ESRCH
+      false
+    end
+  
+    def poll
+      @io_stream.poll
+    end
+
+    def write_object(obj, write)
+      data = Marshal.dump(obj).gsub("\n", "@NDELIMITER@") + "\n"
+      write.write data
+    end
+
+    def read_object(read)
+      data = read.gets
+      Marshal.load(data.chomp.gsub("@NDELIMITER@", "\n"))
+    end
+  
+    def nonblock_read_from_child()
+      data = @io_stream.read
+      if(data)
+        return Marshal.load(data.chomp.gsub("@NDELIMITER@", "\n"))
+      end
+      return nil
+    end
+  
+    def nonblock_write_to_child(obj)
+      data = Marshal.dump(obj).gsub("\n", "@NDELIMITER@") + "\n"
+      @io_stream.write(data)
+    end
+
+    def read_from_child
+      read_object(@parent_read)
+    end
+
+    def write_to_child(obj)
+      write_object(obj, @parent_write)
+    end
+
+    def read_from_parent
+      read_object(@child_read)
+    end
+
+    def write_to_parent(obj)
+      write_object(obj, @child_write)
+    end
+
+    def wait_after_fork
+      @child_read.close
+      @child_write.close
+
+      install_exit_handler
+      install_signal_handler
+  
+      Thread.new {
+        result = read_from_child
+        raise "Failed to start worker pid #{ @pid }" unless result == :ready
+        result
+      }
+    end
+
+    def install_exit_handler
+      at_exit do
+        next unless alive?
+        begin
+          Process.kill("KILL", @pid)
+          Process.wait(@pid)
+        rescue Errno::ESRCH
+          # noop
+        rescue => e
+          puts "error at_exit: #{ e }"
+          raise e
+        end
+      end
+    end
+
+    def install_signal_handler
+      [:INT, :QUIT].each do |signal|
+        old_handler = Signal.trap(signal) {
+          Process.kill(signal, @pid)
+          Process.wait(@pid)
+          old_handler.call
+        }
+      end
+    end
+  end
+
+  def self.identify_image(path,&block)
+    proc = lambda() {|e|      
+      unless File.directory?(e)
+        begin
+          fname = File.basename(e)
+          # TODO
+          if(fname.index("@STANDARDIZED@_") == 0 or fname.index("@Q@_") == 0)
+            return nil
+          end
+          
+          fsize = File.binread(e).size
+          if(fsize > 1024*1024*5)
+            obj = {}
+            obj[:source_path] = e
+            obj[:source_filename] = File.basename(e)
+            obj[:error] = "Too big file :" + fsize.to_s
+            return obj
+          end
+          if(fsize < 1024*10)
+            obj = {}
+            obj[:source_path] = e
+            obj[:source_filename] = File.basename(e)
+            obj[:error] = "Too small file :" + fsize.to_s
+            return obj
+          end
+          
+          time = Time.new
+          img = Magick::Image.from_blob( File.read(e) ).shift
+          #puts (Time.new - time).to_s + " : " + fsize.to_s + " : "+e
+          if %w(JPEG GIF PNG).member?(img.format)
+            obj = {}
+            obj[:source_path] = e
+            obj[:source_filename] = File.basename(e)
+            obj[:image] = img;
+            obj[:time] = Time.new - time
+            obj[:size] = fsize
+            return obj
+          else
+            obj = {}
+            obj[:source_path] = e
+            obj[:source_filename] = File.basename(e)
+            obj[:image] = img;
+            obj[:error] = "Unknown file"
+            return obj
+          end        
+            
+        rescue => err
+          puts "Warning: cought a something error."
+          obj = {}
+          obj[:source_path] = e
+          obj[:source_filename] = File.basename(e)
+          obj[:image] = img;
+          obj[:error] = err
+          return obj
+        end
+      end
+      return nil
+    }
+    unless File.directory?((path))
+      obj = proc.call(path)
+      block.call(obj) if(obj)
+    else
+      Dir.glob(path + "/" + "**/*").each{|e|
+        obj = proc.call(e)
+        block.call(obj) if(obj)
+      }
+    end
+  end
+
+  def self.find_image(path,options={:no_check => false},&block)
+    unless File.exist?(path)
+      puts "Error"
+      puts " File does not exist => " + path
+      return
+    end
+    proc = lambda() {|e|
+      unless File.directory?(e)
+        begin
+          if(options and options[:no_check] == true)
+            if %w(.JPG .JPEG .GIF .PNG).member?(File.extname(e).upcase)
+              obj = {}
+              obj[:source_path] = e
+              obj[:source_filename] = File.basename(e)
+              return obj
+            end
+          else
+            if %w(.JPG .JPEG .GIF .PNG).member?(File.extname(e).upcase)
+              img = Magick::Image.from_blob( File.read(e) ).shift
+              if %w(JPEG GIF PNG).member?(img.format.to_s)
+                obj = {}
+                obj[:source_path] = e
+                obj[:source_filename] = File.basename(e)
+                obj[:image] = img;
+                return obj
+              end
+            end
+          end
+        rescue => e
+          puts "Warning: caught a something error."
+          puts e.class
+          puts e.message
+          puts e.backtrace
+          # nothing to do
+        end
+      end
+      return nil
+    }
+    unless File.directory?(path)
+      obj = proc.call(path)
+      block.call(obj) if(obj)
+    else
+      Dir.glob(path + "/" + "**/*").each{|e|
+        obj = proc.call(e)
+        block.call(obj) if(obj)
+      }
+    end
+  end
+
+  def self.high_quality_resize(stream)
+    img = Magick::Image.from_blob(stream).first
+    width = img.columns
+    height = img.rows
+    if(width > 512 and height > 512)
+      img = img.resize_to_fit(512, 512)
+    end
+    img.to_blob {
+      self.quality = 90
+      self.format = "jpeg"
+    }
+  end
+
+  def self.low_quality_resize(stream)
+    img = Magick::Image.from_blob(stream).first
+    img = img.resize(224,224)
+    img.to_blob {
+      self.quality = 80
+      self.format = "jpeg"
+    }
+  end
+
+  def self.prob_resize(stream)
+    if(Random.rand() < 0.9)
+      return low_quality_resize(stream)
+    end
+    return high_quality_resize(stream)
+  end
+
+
+  def self.standardize(path,options={:mode=>:delete})
+    mode = options[:mode]
+    dest = options[:dest]
+    unless(mode)
+      puts "Error"
+      puts "Require parameter"
+      puts " Specify a :mode => :delete or :move or :rename"
+      exit(9)
+    end
+    unless(%w{delete delete rename}.member?(mode.to_s))
+      puts "Error"
+      puts "Require parameter"
+      puts " Specify a :mode => :delete or :move or :rename"
+      exit(9)
+    end
+    
+    dirname = path
+    unless File.directory?(path)
+      dirname = File.dirname(path)
+    end
+    puts "Entry path : " + path
+    puts "Destination : " + dirname
+
+
+    identify_image(path) {|e|
+      source_path     = e[:source_path]
+      source_filename = e[:source_filename];
+      dst_dirname     = File.dirname(source_path)
+      if(e[:error])
+        File.delete(source_path) if File.exist?(source_path)
+        if(mode == :delete)
+          File.delete(source_path) if File.exist?(source_path)
+          next
+        elsif(mode == :rename)
+          FileUtils.mv(source_path,File.join(dst_dirname,mark+SecureRandom.uuid+"."+source_filename.split(".")[-1]))
+          next
+        else
+          next
+        end
+      end
+      img             = e[:image]
+      width           = img.columns
+      height          = img.rows
+      mark            = ""
+      
+      # Check already standardized file or not.
+      if source_filename.index("@STANDARDIZED@") == 0 or source_filename.index("@Q@") == 0
+        puts "already done : " + source_path
+        next
+      # else
+      #   puts "processing   : " + source_path
+      end
+      
+      # Validaiton check 
+      if(width > 8192 or height > 8192)
+        #puts "too big image: " + source_path
+        mark = "@BIG@_"
+      elsif(width < 300 or height < 300)
+        #puts "thumb image  : " + source_path
+        mark = "@THUMB@_"
+      end
+      
+      puts e[:time].to_s + " : " + e[:size].to_s + " : "  + mark + " : " + source_path
+      
+      if(mark.length > 0)
+        if(mode == :delete)
+          File.delete(source_path) if File.exist?(source_path)
+          next
+        elsif(mode == :rename)
+          FileUtils.mv(source_path,File.join(dst_dirname,mark+SecureRandom.uuid+"."+source_filename.split(".")[-1]))
+          next
+        elsif(mode == :move)
+          if(dest)
+            if(File.exist?(dest))
+              if(File.directory?(dest))
+                FileUtils.mv(source_path,File.join(dest,mark+SecureRandom.uuid+"."+source_filename.split(".")[-1]))
+                next
+              else
+                puts "Error"
+                puts "Destination is not directory.  => " + dest
+                exit(9)
+              end
+            else
+              puts "Error"
+              puts "Destination path does not exist. => " + dest
+              exit(9)
+            end
+          else
+            puts "Error"
+            puts "Destination path is nil."
+            puts "You should specify a destination path for :move mode."
+            exit(9)
+          end
+        end
+      end
+    
+      # keeping ratio
+      if(width > 1024 or height > 1024)
+        img.resize_to_fit!(1024, 1024)
+      end
+      
+      fname = source_filename.split(".")[0]
+      img.format = 'JPEG'
+      begin
+        # Reformat and save
+        img.write(File.join(dst_dirname,"@STANDARDIZED@_"+SecureRandom.uuid+".jpg")) { self.quality = 90 } # 1~100
+        # Delete source file
+        File.delete(source_path) if File.exist?(source_path)
+      rescue => e
+        puts "Write error"
+        puts e.class
+        puts e.message
+        puts e.backtrace
+      end
+      # 10~30KB 80 : Q-TRAIN
+      # 30~60KB 90 : Q-SOURCE
+      # 50~200KB 100 : Q-SOURCE
+    }
+    puts "Done"
+  end
+
+
+
+  class LevdonImpl
+  
+    # def LevdonImpl.dealloc(workers)
+    #     proc {|id|
+    #       begin
+    #         workers.each(&:stop)
+    #         workers = nil
+    #       rescue => e
+    #         # nothing to do
+    #       end
+    #     }
+    # end
+    
+    def initialize()
+      @access_token = "DUMMY"
+      @blocks       = {}
+      @timeout      = 10.0 # default 10sec
+      @request_cluster_num = 1
+      
+      # prediction parameters 
+      @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
+          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
+            end
+          rescue => e
+            error = ""
+            error += e.class.to_s + "\n"
+            error += e.message.to_s + "\n"
+            error += e.backtrace.to_s + "\n"
+          ensure
+            if(io)
+              begin
+                io.close()
+              rescue IOError
+                # nothing to do
+              rescue => e
+                error = ""
+                error += e.class.to_s + "\n"
+                error += e.message.to_s + "\n"
+                error += e.backtrace.to_s + "\n"
+              end
+            end
+          end
+          
+          {:results => ret, :error => error,:parameter => parameter}
+        }
+      }
+      
+      @workers.map(&:run).each(&:join)
+      @roundrobin_counter       = 0
+      @task_stacking_counter    = []
+      @workers.length.times{|i| @task_stacking_counter.push([i,0]) }
+      #ObjectSpace.define_finalizer(self,LevdonImpl.dealloc(@workers))
+      
+      # CTRL + C
+      Signal.trap(:INT) {
+        puts "Stop " + APPLICATION_ID + " clients "
+        close()
+        exit(0)
+      }
+      
+      block.call({:error => nil})
+    end
+    
+    def start(access_token)
+      ret = nil
+      async_start(access_token){|e|
+        ret = e
+      }
+      while(ret == nil)
+        sleep(0.01)
+      end
+      ret
+    end
+  
+    def option(obj)
+      obj.each{|k,v|
+        if(k == :CLASS)
+          @ontologies = v
+        elsif(k == :PARALLEL)
+          @request_cluster_num = v
+        else
+          puts "Invalid option : " + k.to_s
+        end
+      }
+    end
+  
+    def load(any)
+      if(any.class.name == "String")
+        if(any.index("http://") == 0 or any.index("https://") == 0)
+          # from network
+          return open(any).read
+        else
+          # TODO File path checker
+          if(any.length < 1024)
+            # from file
+            return File.open(any).read # File IO
+          else
+            # from memory
+            return any
+          end
+        end
+      else
+        # from memory
+        return any
+      end
+      return nil
+    end
+  
+    def poll
+      @workers.each(&:poll)
+      @workers.map(&:nonblock_read_from_child).each_with_index{|ret,i|
+        begin
+          if(ret)
+            request_id = ret[:parameter][:request_id]
+            key = VUUID + request_id
+            if(@blocks.has_key?(key))
+              @task_stacking_counter[i][1] -= 1
+              @blocks[key].call(ret)
+              @blocks.delete(key)
+            else
+              puts "Error"
+              puts "Invalid response from server."
+            end
+          end
+        rescue => e
+          puts "Response error"
+          puts e.class
+          puts e.message
+          puts e.backtrace
+        end
+      }
+    end
+  
+    def enqueue(*args)
+      target = @task_stacking_counter.sort{|a,b| a[1]-b[1]}[0][0]
+      @task_stacking_counter[target][1] += 1
+      #target = @roundrobin_counter % @workers.length
+      #@roundrobin_counter += 1
+      
+      worker = @workers[target]
+      worker.async_execute(*args)
+    end
+  
+    def async_predict(parameter,&block)
+      raise "expected key: request_id" if(parameter[:request_id])
+      raise "expected key: ontologies" if(parameter[:ontologies])
+      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)
+      @blocks[VUUID+parameter[:request_id]] = block
+    end
+    def queue_size
+      @blocks.length
+    end
+  
+    def close
+      begin
+        @workers.each(&:stop)
+      rescue => e
+        # nothing to do
+      end
+    end
+  
+    def predict(parameter)
+      raise "expected key: request_id" if(parameter[:request_id])
+      raise "expected key: ontologies" if(parameter[:ontologies])
+      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)
+      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
+        }
+      rescue => e
+        puts "Predict error"
+        puts e.class
+        puts e.message
+        puts e.backtrace
+      end
+      return nil
+    end
+  
+  end
+  
+  def self.new
+    LevdonImpl.new
+  end
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: levdon
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Pegara, Inc.
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-05-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: rmagick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.16.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.16.0
+- !ruby/object:Gem::Dependency
+  name: multipart-post
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+description: 
+email:
+- info@pegara.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- levdon.gemspec
+- lib/levdon.rb
+- lib/levdon/version.rb
+homepage: https://www.leviadon.com
+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.6.11
+signing_key: 
+specification_version: 4
+summary: AI(DeepLearning) contents filter library for mastodon.
+test_files: []