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 org.txm.libs.office.WriteODS

import org.txm.searchengine.core.SearchEnginesManager

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

import org.txm.searchengine.ts.TIGERSearchEngine

import org.txm.utils.ConsoleProgressBar

import org.txm.utils.TableReader

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="new_ods_file", usage="file to create", widget="FileSave", required=true, def="result.ods")

                def new_ods_file

@Field @Option(name="query_table_file", usage="A Full TIGERSearch query", widget="FileOpen", required=true, def="queries.ods")

                def query_table_file

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

                def count_sub_matches

@Field @Option(name="sujet_value", usage="", widget="String", required=true, def="[cat=(\"nsubj\"|\"csubj\")]")

                def sujet_value

@Field @Option(name="object_value", usage="", widget="String", required=true, def="[cat=(\"obj\"|\"ccomp\"|\"obj\\\\:advneg\"|\"obj\\\\:advmod\")]")

                def object_value

@Field @Option(name="clauses_count_main", usage="", widget="Boolean", required=true, def="true")

                def clauses_count_main

@Field @Option(name="clauses_count_subordinate", usage="", widget="Boolean", required=true, def="false")

                def clauses_count_subordinate

@Field @Option(name="clauses_count_inserted", usage="", widget="Boolean", required=true, def="false")

                def clauses_count_inserted

@Field @Option(name="print_queries", usage="insert columns with the used queries", widget="Boolean", required=true, def="true")

                def print_queries

@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

if (!clauses_count_main && !clauses_count_subordinate && !clauses_count_inserted) {

        println "Error: at least one clause must be selected"

        return

}

String based_query = """#pivot:[pos="VERB"] 

& #clause:CLAUSEVALUE

& #clause >L #pivot 

& #clause >D #obj:OBJVALUE

& #clause >D #suj:SUJVALUE

& #obj    >L #objhead:[]  & #suj    >L #sujhead:[]"""

String clause_value = "[cat=\"root\" & type=\"VFin\"]" // main clause

if (clauses_count_inserted) {

        clause_value = "[cat=\"Insrt\" & type=\"VFin\"]"

} else if (clauses_count_subordinate) {

        clause_value = "[cat!=(\"root\"|\"Insrt\") & type=\"VFin\"]"

}

based_query = based_query.replaceAll("CLAUSEVALUE", clause_value)

based_query = based_query.replaceAll("OBJVALUE", object_value)

based_query = based_query.replaceAll("SUJVALUE", sujet_value)

println "based_query=$based_query"

def SVO_queries = new LinkedHashMap<String, String>()

SVO_queries["SVO"] = "& #sujhead .* #pivot   & #pivot   .* #objhead"

SVO_queries["SOV"] = "& #sujhead .* #objhead & #objhead .* #pivot"

SVO_queries["OSV"] = "& #objhead .* #sujhead & #sujhead .* #pivot"

SVO_queries["OVS"] = "& #objhead .* #pivot   & #pivot   .* #sujhead"

SVO_queries["VSO"] = "& #pivot   .* #sujhead & #sujhead .* #objhead"

SVO_queries["VOS"] = "& #pivot   .* #objhead & #objhead .* #sujhead"

int ncols = 2 + (SVO_queries.keySet().size() * (print_queries?2:1))

def test_queries = []

TableReader reader = new TableReader(query_table_file)

reader.readHeaders()

WriteODS writer = new WriteODS(new_ods_file);

def headers = reader.getHeaders()

if (!(headers.contains("mesure") && headers.contains("valeur") && headers.contains("requête"))) { // mesure, valeur, requête

        println "Error: 'mesure', 'valeur', 'requête' columns not found"

        return

}

while (reader.readRecord()) {

        test_queries << [

                reader.get("mesure"),

                reader.get("valeur"),

                reader.get("requête")

        ]

}

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

TIGERSearchEngine tse = SearchEnginesManager.getTIGERSearchEngine()

def results = new LinkedHashMap()

for (def corpus : selection) {

        cpb.tick()

        writer.newTable(corpus.getName())

        def root = corpus.getRootCorpusBuild();

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

        if (!tse.hasIndexes(corpus)) {

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

                continue;

        }

        writer.declareRowsAndColumns(0, ncols)

        def cols = ["mesure", "valeur"] 

        for (String col : SVO_queries.keySet()) {

                if (print_queries) cols << "q"+col

                cols << col

        }

        writer.writeLine(cols)

        def tcorpus = tse.getTSCorpus(corpus);

        def based_sentences_min_max = tse.getSentMinMax(corpus);

        for (def test : test_queries) {

                def test_query = test[2]

                def lineToWrite = []

                lineToWrite << test[0]

                lineToWrite << test[1]

                for (def k : SVO_queries.keySet()) {

                        def svo_query = based_query+"\n"+SVO_queries[k]+"\n"+test_query

                        if (debug > 0) println svo_query

                        def test_result = tcorpus.manager.processQuery(svo_query, based_sentences_min_max[0], based_sentences_min_max[1], 9999999);

                        if (print_queries) lineToWrite << svo_query

                        if (count_sub_matches) {

                                lineToWrite << test_result.submatchSize()

                        } else {

                                lineToWrite << test_result.size()

                        }

                }

                writer.writeLine(lineToWrite)

        }

}

writer.save()

cpb.done()

return results