Class: Lingo::Attendee::Sequencer

Inherits:
BufferedAttendee show all
Includes:
Lingo::ArrayUtils
Defined in:
lib/lingo/attendee/sequencer.rb

Overview

– Der Sequencer ist von seiner Funktion her ähnlich dem Multiworder. Der Multiworder nutzt zur Erkennung von Mehrwortgruppen spezielle Wörterbücher, der Sequencer hingegen definierte Folgen von Wortklassen. Mit dem Sequencer können Indexterme generiert werden, die sich über mehrere Wörter erstrecken. Die Textfolge “automatische Indexierung und geniale Indexierung” wird bisher in die Indexterme “automatisch”, “Indexierung” und “genial” zerlegt. Über die Konfiguration kann der Sequencer Mehrwortgruppen identifizieren, die z.B. aus einem Adjektiv und einem Substantiv bestehen. Mit der o.g. Textfolge würde dann auch “Indexierung, automatisch” und “Indexierung, genial” als Indexterm erzeugt werden. Welche Wortklassenfolgen erkannt werden sollen und wie die Ausgabe aussehen soll, wird dem Sequencer über seine Konfiguration mitgeteilt.

Mögliche Verlinkung

Erwartet

Daten vom Typ Word z.B. von Wordsearcher, Decomposer, Ocr_variator, Multiworder

Erzeugt

Daten vom Typ Word (mit Attribut WA_SEQUENCE). Je erkannter Mehrwortgruppe wird

ein zusätzliches Word-Objekt in den Datenstrom eingefügt. Z.B. für Ocr_variator, Sequencer, Vector_filter

Parameter

Kursiv dargestellte Parameter sind optional (ggf. mit Angabe der Voreinstellung). Alle anderen Parameter müssen zwingend angegeben werden.

in

siehe allgemeine Beschreibung des Attendee

out

siehe allgemeine Beschreibung des Attendee

stopper

(Standard: TA_PUNCTUATION, TA_OTHER) Gibt die Begrenzungen an, zwischen denen der Sequencer suchen soll, i.d.R. Satzzeichen und Sonderzeichen, weil sie kaum in einer Mehrwortgruppen vorkommen.

Konfiguration

Der Sequencer benötigt zur Identifikation von Mehrwortgruppen Regeln, nach denen er arbeiten soll. Die benötigten Regeln werden nicht als Parameter, sondern in der Sprachkonfiguration hinterlegt, die sich standardmäßig in der Datei de.lang befindet (YAML-Format).

language:
  attendees:
    sequencer:
      sequences: [ [AS, "2, 1"], [AK, "2, 1"] ]

Hiermit werden dem Sequencer zwei Regeln mitgeteilt: Er soll Adjektiv-Substantiv- (AS) und Adjektiv-Kompositum-Folgen (AK) erkennen. Zusätzlich ist angegeben, in welchem Format die dadurch ermittelte Wortfolge ausgegeben werden soll. In diesem Beispiel also zuerst das Substantiv und durch Komma getrennt das Adjektiv.

Beispiele

Bei der Verarbeitung einer normalen Textdatei mit der Ablaufkonfiguration t1.cfg

meeting:
  attendees:
    - text_reader:   { out: lines, files: '$(files)' }
    - tokenizer:     { in: lines, out: token }
    - word_searcher: { in: token, out: words, source: 'sys-dic' }
    - sequencer:     { in: words, out: seque }
    - debugger:      { in: seque, prompt: 'out>' }

ergibt die Ausgabe über den Debugger: lingo -c t1 test.txt

out> *FILE('test.txt')
out> <Lingo|?>
out> <kann = [(koennen/v)]>
out> <indexierung, automatisch|SEQ = [(indexierung, automatisch/q)]>
out> <automatische = [(automatisch/a)]>
out> <Indexierung = [(indexierung/s)]>
out> <und = [(und/w)]>
out> <indexierung, genial|SEQ = [(indexierung, genial/q)]>
out> <geniale = [(genial/a), (genialisch/a)]>
out> <Indexierung = [(indexierung/s)]>
out> :./PUNC:
out> *EOL('test.txt')
out> *EOF('test.txt')

++

Constant Summary collapse

UNK = 
%w[#]
NUM = 
%w[0]
CLASS_RE = 
%r{[a-z#{NUM.join}]}o
REGEX_RE = 
%r{
  ( #{CLASS_RE}+ )
  |
  \[
    ( #{CLASS_RE}+ )
  \]
  |
  \(
    (?: \?: )?
    ( #{CLASS_RE}+ (?: \| #{CLASS_RE}+ )* )
  \)
}xo
FULL_CLASS_RE = 
%r{\A(?:#{CLASS_RE})+\z}o
FULL_REGEX_RE = 
%r{\A(?:#{REGEX_RE})+\z}o

Constants inherited from Lingo::Attendee

DEFAULT_SKIP, TERMINALS

Constants included from Language

Language::CHAR_PUNCT, Language::LA_SORTORDER, Language::TA_ABBREVIATION, Language::TA_HELP, Language::TA_HTML, Language::TA_NUMBER, Language::TA_OTHER, Language::TA_PUNCTUATION, Language::TA_SKIP, Language::TA_SPACE, Language::TA_URL, Language::TA_WIKI, Language::TA_WORD, Language::WA_COMPOUND, Language::WA_IDENTIFIED, Language::WA_MULTIWORD, Language::WA_SEQUENCE, Language::WA_UNKMULPART, Language::WA_UNKNOWN, Language::WA_UNSET

Instance Attribute Summary

Attributes inherited from Lingo::Attendee

#lingo, #subscribers

Instance Method Summary collapse

Methods inherited from BufferedAttendee

#initialize, #process

Methods inherited from Lingo::Attendee

#command, #forward, #initialize

Constructor Details

This class inherits a constructor from Lingo::BufferedAttendee

Instance Method Details

#control(cmd) ⇒ Object 



154
155
156
 
# File 'lib/lingo/attendee/sequencer.rb', line 154

def control(cmd, *)
  process_buffer if [:RECORD, :EOF].include?(cmd)
end

#init ⇒ Object

Raises:



123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
 
# File 'lib/lingo/attendee/sequencer.rb', line 123

def init
  @stopper = get_ary('stopper', DEFAULT_SKIP)
               .push(WA_UNKNOWN, WA_UNKMULPART)

  @mwc = get_key('multiword', LA_MULTIWORD)

  @cls, @seq = [], []

  get_key('sequences').each { |str, fmt|
    seq, fmt = lambda { |*a| @seq << (a << fmt) },
      fmt == true ? '|' : fmt ? fmt.gsub(/\d+/, '%\&$s') : nil

    @cls.concat(cls = (str = str.downcase).scan(CLASS_RE))

    case str
      when FULL_CLASS_RE then seq[str, cls]
      when FULL_REGEX_RE then m = []
        str.scan(REGEX_RE) { |m1, m2, m3|
          m1 ? m1.each_char { |c| m << [c] } : m << (
          m2 ? m2.chars : m3.split('|').map(&:chars)) }

        combinations(*m) { |q| seq[q.join, q.flatten] }
      else seq[Regexp.new(str), nil]
    end
  }

  @cls.uniq!

  raise MissingConfigError.new(:sequences) if @seq.empty?
end

#process_buffer ⇒ Object 



162
163
164
165
 
# File 'lib/lingo/attendee/sequencer.rb', line 162

def process_buffer
  process_seq if @buffer.size > 1
  flush(@buffer)
end

#process_buffer? ⇒ Boolean

Returns:

  • (Boolean) 


158
159
160
 
# File 'lib/lingo/attendee/sequencer.rb', line 158

def process_buffer?
  (obj = @buffer.last).is_a?(WordForm) && @stopper.include?(obj.attr)
end