Laboratoire ICAR » Plateforme TXM

// Copyright © 2019 ENS de Lyon, CNRS, University of Franche-Comté

// Licensed under the terms of the GNU General Public License (http://www.gnu.org/licenses)

// @author mdecorde

// STANDARD DECLARATIONS

package org.txm.macro.tiger.exploit

import groovy.transform.Field

import java.util.List

import org.txm.searchengine.core.EmptySelection

import org.txm.searchengine.core.SearchEnginesManager

import org.txm.searchengine.cqp.AbstractCqiClient

import org.txm.searchengine.cqp.CQPSearchEngine

import org.txm.searchengine.cqp.corpus.*

import org.txm.searchengine.ts.TIGERSearchEngine

import org.txm.searchengine.ts.TSCorpus

import org.txm.searchengine.ts.TSResult

import org.txm.utils.ConsoleProgressBar

import org.txm.utils.logger.Log

import ims.tiger.corpus.Sentence

import ims.tiger.query.api.*;

def scriptName = this.class.getSimpleName()

def selection = []

for (def s : corpusViewSelections) {

        if (s instanceof CQPCorpus) selection << s

        else if (s instanceof Partition) selection.addAll(s.getParts())

}

if (selection.size() == 0) {

        println "** $scriptName: please select a Corpus or a Partition in the Corpus view: "+corpusViewSelections

        return false

} else {

        for (def c : selection) c.compute(false)

}

@Field @Option(name="tiger_query", usage="A Full TIGERSearch query", widget="Text", required=true, def="[]")

                String tiger_query

@Field @Option(name="labels", usage="List of TIGER labels separated with ','", widget="String", required=true, def="A,B,C")

                def labels

@Field @Option(name="properties", usage="List of properties separated with ','", widget="String", required=true, def="word, word, word")

                def properties

@Field @Option(name="count_subgraph", usage="A Full TIGERSearch query", widget="Boolean", required=true, def="true")

                def count_subgraph

@Field @Option(name="sort_column", usage="choose between the len or freq columns", widget="StringArray", metaVar="freq        labels", required=true, def="freq")

                String sort_column

                @Field @Option(name="max_lines", usage="choose between the len or freq columns", widget="Integer", metaVar="freq        labels", required=true, def="-1")

                int max_lines

@Field @Option(name="debug", usage="Show internal variable content", widget="StringArray", metaVar="OFF        ON        ALL        REALLY ALL", required=true, def="OFF")

                debug

if (!ParametersDialog.open(this)) return

if (debug == "OFF") debug = 0; else if (debug == "ON") debug = 1; else if (debug == "ALL") debug = 2 else if (debug == "REALLY ALL") debug = 3

TIGERSearchEngine tse = SearchEnginesManager.getTIGERSearchEngine()

if (labels.length() == 0) {

        println "Error: no label given. Aborting"

        return false;

} else {

        labels = labels.split(",")

}

if (properties.length() == 0) {

        println "Error: no property given. Aborting"

        return false;

} else {

        properties = properties.split(",")

}

if (properties.size() != labels.size()) {

        println "Error: the number of labels and properties does not matches. labels=$labels properties=$properties (${labels.size()} != {properties.size()})"

        return false;

}

def missing = []

for (def l : labels) {

        if (!tiger_query.contains("#${l}:")) {

                missing << l

        }

}

if (missing.size() > 0) {

        println "Error: $missing label(s) not found in query: $tiger_query"

        return false

}

def results = new LinkedHashMap()

def total_counts = [:] // List<String> -> Integer

ConsoleProgressBar cpb = new ConsoleProgressBar(selection.size())

for (def corpus : selection) {

        def counts = [:] // List<String> -> Integer

        def root = corpus.getRootCorpusBuild();

        File buildDirectory = new File(root.getProjectDirectory(), "tiger");

        if (!tse.hasIndexes(corpus)) {

                println "Warning: skipping $corpus: no TIGERSearch indexes found."

                continue;

        }

        def tcorpus = tse.getTSCorpus(corpus);

        def index = tcorpus.getIndex()

        def sentences_min_max = tse.getSentMinMax(corpus);

        MatchResult mresult = tcorpus.manager.processQuery(tiger_query, sentences_min_max[0], sentences_min_max[1], 9999999);

        List<String> variables = java.util.Arrays.asList(mresult.getVariableNames());

        def iVariables = []

        for (def l : labels) {

                iVariables << variables.indexOf(l)

        }

        def matches = mresult.matches

        int size = matches.keySet().size();

        if (debug > 0) println "$size sentences matched."

        for (int sent : matches.keySet()) { // the matching sentences

                if (!mresult.isMatchingSentence(sent)) continue;

                int sent_submatch_size = mresult.getSentenceSubmatchSize(sent);

                //println "sent no $sent with $sent_submatch_size submatches : "

                def sentence = index.getSentence(sent)

                for (int j = 0 ; j < sent_submatch_size ; j++) {

                        //println "submatch no $j"

                        def positions = mresult.getSentenceSubmatchAt(sent, j)

                        def strings = []

//                        println "        positions=$positions"

//                        println "        properties=$properties"

//                        println "        iVariables=$iVariables"

                        int t = 0;

                        for (int iV : iVariables) {

                                def node = sentence.getNode(positions[iV])

                                String value = node.getFeature(properties[t])

                                t++

                                if (value == null) {

                                        //println "Warning: no '${properties[iV]}' feature found in node="+node.getFeatures()

                                        value = "NA"

                                }

                                strings << value

                        }

                        if (!counts.containsKey(strings)) {

                                counts[strings] = 0;

                        }

                        if (!total_counts.containsKey(strings)) {

                                total_counts[strings] = 0;

                        }

                        counts[strings] = counts[strings] + 1

                        total_counts[strings] = total_counts[strings] + 1

                        if (!count_subgraph) break;

                }

        }

        results[corpus] = counts

        cpb.tick()

        // DEBUG

        //        def keys = []

        //        keys.addAll(counts.keySet())

        //        if ("freq".equals(sort_column)) {

        //                keys = keys.sort() {-counts[it]}

        //        } else {

        //                keys = keys.sort()

        //        }

        //

        //        for (def k : keys) {

        //                println "${k.join('_')}        ${counts[k]}"

        //        }

}

cpb.done()

def keys = []

keys.addAll(total_counts.keySet())

if ("freq".equals(sort_column)) {

        keys = keys.sort() {-total_counts[it]}

} else {

        keys = keys.sort()

}

println properties.join(", ")+"\t"+"F\t"+selection.join("\t")

int nline = 0;

for (def k : keys) {

        print "${k.join('_')}        ${total_counts[k]}"

        if (selection.size() > 1) {

                for (def corpus : selection) {

                        def v = results[corpus][k];

                        if (v == null) v = 0;

                        print "\t"+v

                }

        }

        println ""

        nline++

        if (max_lines > 0 && nline >= max_lines) {

                println "... (${keys.size() - max_lines})"

                break;

        }

}