opener-polarity-tagger 2.5.0 → 3.1.2

data/exec/polarity-tagger.rb

@@ -1,19 +1,9 @@
 #!/usr/bin/env ruby
 
 require 'opener/daemons'
-require 'opener/core'
 
 require_relative '../lib/opener/polarity_tagger'
 
-switcher      = Opener::Core::ResourceSwitcher.new
-switcher_opts = {}
+daemon = Opener::Daemons::Daemon.new(Opener::PolarityTagger)
 
-parser = Opener::Daemons::OptParser.new do |opts|
-  switcher.bind(opts, switcher_opts)
-end
-
-options = parser.parse!(ARGV)
-daemon  = Opener::Daemons::Daemon.new(Opener::PolarityTagger, options)
-
-switcher.install(switcher_opts)
 daemon.start

data/lib/opener/polarity_tagger.rb

@@ -1,101 +1,27 @@
 require 'open3'
 require 'opener/core'
+require 'nokogiri'
+require 'hashie'
 
 require_relative 'polarity_tagger/version'
 require_relative 'polarity_tagger/cli'
+require_relative 'polarity_tagger/external'
+
+require_relative 'polarity_tagger/internal'
 
 module Opener
-  ##
-  # Ruby wrapper around the Python based polarity tagger.
-  #
-  # @!attribute [r] options
-  #  @return [Hash]
-  #
   class PolarityTagger
-    attr_reader :options, :args
 
-    ##
-    # @param [Hash] options
-    #
-    # @option options [Array] :args Collection of arbitrary arguments to pass
-    #  to the underlying kernel.
-    #
-    def initialize(options = {})
+    def initialize options = {}
       @args    = options.delete(:args) || []
       @options = options
+      @klass   = if ENV['LEGACY'] then External else Internal end
+      @proc    = @klass.new args: @args
     end
 
-    ##
-    # Returns a String containing the command to use for executing the kernel.
-    #
-    # @return [String]
-    #
-    def command
-      return "#{adjust_python_path} python -E #{kernel} #{lexicon_path} #{args.join(" ")}"
-    end
-
-    def lexicon_path
-      if path = options[:resource_path]
-        return "--lexicon-path #{path}"
-      elsif path = ENV['POLARITY_LEXICON_PATH']
-        return "--lexicon-path #{path}"
-      else
-        return nil
-      end
-    end
-
-    ##
-    # Processes the input and returns an Array containing the output of STDOUT,
-    # STDERR and an object containing process information.
-    #
-    # @param [String] input The text of which to detect the language.
-    # @return [Array]
-    #
-    def run(input)
-      begin
-        stdout, stderr, process = capture(input)
-        raise stderr unless process.success?
-        return stdout
-      rescue Exception => error
-        return Opener::Core::ErrorLayer.new(input, error.message, self.class).add
-      end
-    end
-
-    protected
-    ##
-    # @return [String]
-    #
-    def adjust_python_path
-      site_packages =  File.join(core_dir, 'site-packages')
-      "env PYTHONPATH=#{site_packages}:$PYTHONPATH"
-    end
-
-    ##
-    # capture3 method doesn't work properly with Jruby, so
-    # this is a workaround
-    #
-    def capture(input)
-      Open3.popen3(*command.split(" ")) {|i, o, e, t|
-        out_reader = Thread.new { o.read }
-        err_reader = Thread.new { e.read }
-        i.write input
-        i.close
-        [out_reader.value, err_reader.value, t.value]
-      }
+    def run input
+      @proc.run input
     end
 
-    ##
-    # @return [String]
-    #
-    def core_dir
-      return File.expand_path('../../../core', __FILE__)
-    end
-
-    ##
-    # @return [String]
-    #
-    def kernel
-      return File.join(core_dir, 'poltagger-basic-multi.py')
-    end
-  end # PolarityTagger
-end # Opener
+  end
+end

data/lib/opener/polarity_tagger/cli.rb

@@ -3,75 +3,66 @@ require 'opener/core'
 module Opener
   class PolarityTagger
     ##
-    # CLI wrapper around {Opener::LanguageIdentifier} using OptionParser.
+    # CLI wrapper around {Opener::LanguageIdentifier} using Slop.
     #
-    # @!attribute [r] options
-    #  @return [Hash]
-    # @!attribute [r] option_parser
-    #  @return [OptionParser]
+    # @!attribute [r] parser
+    #  @return [Slop]
     #
     class CLI
-      attr_reader :options, :option_parser, :resource_switcher
+      attr_reader :parser
+
+      def initialize
+        @parser = configure_slop
+      end
 
       ##
-      # @param [Hash] options
+      # @param [Array] argv
       #
-      def initialize(options = {})
-        @options = options
+      def run(argv = ARGV)
+        parser.parse(argv)
+      end
 
-        @resource_switcher = Opener::Core::ResourceSwitcher.new
-        component_options, options[:args] = Opener::Core::ArgvSplitter.split(options[:args])
+      ##
+      # @return [Slop]
+      #
+      def configure_slop
+        Slop.new strict: false, indent: 2, help: true do
+          banner 'Usage: polarity-tagger [OPTIONS] -- [PYTHON OPTIONS]'
 
-        @option_parser = OptionParser.new do |opts|
-          opts.program_name   = 'polarity-tagger'
-          opts.summary_indent = '  '
+          separator <<-EOF.chomp
 
-          resource_switcher.bind(opts, @options)
+About:
 
-          opts.on('-h', '--help', 'Shows this help message') do
-            show_help
-          end
+    Component for tagging the polarity of elements in a KAF document. This
+    command reads input from STDIN.
 
-          opts.on('-v', '--version', 'Shows the current version') do
-            show_version
-          end
+Examples:
 
-          opts.on('-l', '--log', 'Enable logging to STDERR') do
-            @options[:logging] = true
-          end
-        end
+    Processing a KAF file:
 
-        option_parser.parse!(component_options)
-        force = false
-        resource_switcher.install(@options, force)
-      end
+        cat some_file.kaf | polarity-tagger
 
-      ##
-      # @param [String] input
-      #
-      def run(input)
-        tagger = PolarityTagger.new(options)
+    Displaying the underlying kernel options:
 
-        stdout, stderr, process = tagger.run(input)
+        polarity-tagger -- --help
 
-        puts stdout
-      end
+          EOF
 
-      private
+          separator "\nOptions:\n"
 
-      ##
-      # Shows the help message and exits the program.
-      #
-      def show_help
-        abort option_parser.to_s
-      end
+          on :v, :version, 'Shows the current version' do
+            abort "polarity-tagger v#{VERSION} on #{RUBY_DESCRIPTION}"
+          end
 
-      ##
-      # Shows the version and exits the program.
-      #
-      def show_version
-        abort "#{option_parser.program_name} v#{VERSION} on #{RUBY_DESCRIPTION}"
+          run do |opts, args|
+            tagger = PolarityTagger.new(:args => args)
+            input  = STDIN.tty? ? nil : STDIN.read
+
+            puts tagger.run(input)
+          end
+        end
       end
-    end # CLI
-  end # PolarityTagger
-end # Opener
+
+    end
+  end
+end

data/lib/opener/polarity_tagger/external.rb

@@ -0,0 +1,105 @@
+module Opener
+  class PolarityTagger
+    ##
+    # Ruby wrapper around the Python based polarity tagger.
+    #
+    # @!attribute [r] options
+    #  @return [Hash]
+    #
+    # @!attribute [r] args
+    #  @return [Array]
+    #
+    class External
+
+      attr_reader :options, :args
+
+      ##
+      # @param [Hash] options
+      #
+      # @option options [Array] :args Collection of arbitrary arguments to pass
+      #  to the underlying kernel.
+      #
+      # @option options [String] :resource_path Path to the lexicons to use.
+      #
+      def initialize options = {}
+        @args    = options.delete(:args) || []
+        @options = options
+      end
+
+      ##
+      # Returns a String containing the command to use for executing the kernel.
+      #
+      # @return [String]
+      #
+      def command
+        return "#{adjust_python_path} python -E #{kernel} #{lexicon_path} #{args.join(" ")}"
+      end
+
+      ##
+      # @return [String]
+      #
+      def lexicon_path
+        path = options[:resource_path] || ENV['RESOURCE_PATH'] ||
+          ENV['POLARITY_LEXICON_PATH']
+
+        return path ? "--lexicon-path #{path}" : nil
+      end
+
+      ##
+      # Processes the input and returns an Array containing the output of STDOUT,
+      # STDERR and an object containing process information.
+      #
+      # @param [String] input The text of which to detect the language.
+      # @return [Array]
+      #
+      def run(input)
+        stdout, stderr, process = capture(input)
+
+        raise stderr unless process.success?
+        puts stderr if ENV['DEBUG']
+
+        return stdout
+      end
+
+      protected
+
+      ##
+      # @return [String]
+      #
+      def adjust_python_path
+        site_packages =  File.join(core_dir, 'site-packages')
+
+        "env PYTHONPATH=#{site_packages}:$PYTHONPATH"
+      end
+
+      ##
+      # capture3 method doesn't work properly with Jruby, so
+      # this is a workaround
+      #
+      def capture(input)
+        Open3.popen3(*command.split(" ")) {|i, o, e, t|
+          out_reader = Thread.new { o.read }
+          err_reader = Thread.new { e.read }
+          i.write input
+          i.close
+          [out_reader.value, err_reader.value, t.value]
+        }
+      end
+
+      ##
+      # @return [String]
+      #
+      def core_dir
+        File.expand_path '../../../../core', __FILE__
+      end
+
+      ##
+      # @return [String]
+      #
+      def kernel
+        File.join core_dir, 'poltagger-basic-multi.py'
+      end
+
+    end
+  end
+end

data/lib/opener/polarity_tagger/internal.rb

@@ -0,0 +1,57 @@
+require_relative 'lexicons_cache'
+require_relative 'lexicon_map'
+require_relative 'kaf/document'
+
+module Opener
+  class PolarityTagger
+    class Internal
+
+      DESC        = 'VUA polarity tagger multilanguage'
+      LAST_EDITED = '21may2014'
+      VERSION     = '1.2'
+
+      CACHE = LexiconsCache.new
+
+      def initialize ignore_pos: false, **params
+        @ignore_pos = ignore_pos
+      end
+
+      def run input
+        @kaf = KAF::Document.from_xml input
+        @map = @kaf.map = CACHE[@kaf.language]
+
+        negators = 0
+        @kaf.terms.each do |t|
+          lemma = t.lemma&.downcase
+          pos   = if @ignore_pos then nil else t.pos end
+          attrs = Hashie::Mash.new
+
+          lexicon, polarity_pos = @map.by_polarity lemma, pos
+
+          if lexicon.polarity != 'unknown'
+            attrs.polarity = lexicon.polarity
+          end
+          if l = @map.by_negator(lemma)
+            negators += 1
+            lexicon, polarity_pos = l, nil
+            attrs.sentiment_modifier = 'shifter'
+          end
+          if l = @map.by_intensifier(lemma)
+            lexicon, polarity_pos = l, nil
+            attrs.sentiment_modifier = 'intensifier'
+          end
+
+          if attrs.size > 0
+            attrs.resource = lexicon.resource if lexicon.resource
+            t.setPolarity attrs, polarity_pos
+          end
+        end
+
+        @kaf.add_linguistic_processor DESC, "#{LAST_EDITED}_#{VERSION}", 'terms'
+
+        @kaf.to_xml
+      end
+
+    end
+  end
+end

data/lib/opener/polarity_tagger/kaf/document.rb

@@ -0,0 +1,53 @@
+require_relative 'term'
+
+module Opener
+  module KAF
+    class Document
+
+      attr_reader :document
+      attr_reader :lexicons
+
+      attr_accessor :map
+
+      def initialize xml
+        @document = xml
+      end
+
+      def self.from_xml xml
+        new Nokogiri::XML xml
+      end
+
+      def language
+        @language ||= @document.at_xpath('KAF').attr 'xml:lang'
+      end
+
+      def terms
+        @terms ||= collection 'KAF/terms/term', Term
+      end
+
+      def add_linguistic_processor name, version, layer, timestamp: false
+        header  = @document.at('kafHeader') || @document.root.add_child('<kafHeader/>')
+        procs   = header.css('linguisticProcessors').find{ |l| l.attr(:layer) == layer }
+        procs ||= header.add_child("<linguisticProcessors layer='#{layer}'/>")
+        lp      = procs.add_child('<lp/>')
+        lp.attr(
+          timestamp: if timestamp then Time.now.iso8601 else '*' end,
+          version:   version,
+          name:      name,
+        )
+        lp
+      end
+
+      def to_xml
+        @document.to_xml indent: 2
+      end
+
+      protected
+
+      def collection query, wrapper
+        @document.xpath(query).map{ |node| wrapper.new self, node }
+      end
+
+    end
+  end
+end