Laboratoire ICAR » Plateforme TXM

package tests

import org.txm.rcpapplication.views.*

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

/*

import java.awt.Dimension

import java.util.UUID;

import javax.swing.JFrame;

import javax.swing.JOptionPane;

import org.txm.Toolbox

import org.txm.searchengine.cqp.MemCqiClient

import org.txm.searchengine.cqp.MemCqiServer

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

import org.txm.functions.ReferencePattern

import org.txm.rcpapplication.views.CorporaView

import org.txm.searchengine.cqp.corpus.query.Query

*/

/**

 * Create partition with advanced CQL queries and autoname the parts.

 * Can create partitions by defining a multi-level structural units hierarchy or by defining several properties values for one structural unit.

 * Can define some structural units to remove from the resulting parts subcorpus.

 *

 */

// TODO : Log

println "******************************** Starting ********************************************";

// *************************** User parameters ************************************************************

// Test 1 : partition en excluant des sections

def CORPUS_NAME = "LIVRETOPERA2"								// The name of the corpus to partition

def SUBCORPUS_NAME = null										// The name of the subcorpus to partition

//def SUBCORPUS_NAME = "TEST"										// The name of the subcorpus to partition if needed

// FIXME: subcorpus management is bugged, when trying to create a CA on a Partition created on a subcorpus, it doesn't work because of the getLexicon() method which throws a CqiCqpErrorErrorGeneral exception

PartitionQueriesGenerator.STRUCTURAL_UNITS = ['sp']; 					// Applying the partition on these structural units

PartitionQueriesGenerator.STRUCTURAL_UNITS_PROPERTIES = ['who'];		// Applying the partition on these properties of structural units defined above

PartitionQueriesGenerator.STRUCTURAL_UNITS_TO_IGNORE = ['speaker'];	// These structural units will be removed from the partition. NOTE : If doing that you need to define an EXPAND_TARGET

																		// if you want some subcorpus parts that will manage sequential positions queries

PartitionQueriesGenerator.EXPAND_TARGET = 'lg'; 						// Expand the results to this structural unit parent target. If some structural units to ignore are defined

																		// and the expand target is upper on the hierarchy than them, the structural units to ignore WON'T be ignored

//PartitionQueriesGenerator.PARTITION_NAME = 'gugu';					// The partition name. If empty or not defined, the partition will be autonamed regarding of the structural units and properties

// Test 2 : partition sur arborescence (multi-niveau sur 2 niveaux)

//def CORPUS_NAME = "LIVRETOPERA10TEXTES"

//PartitionQueriesGenerator.STRUCTURAL_UNITS = ['text', 'div1'];

//PartitionQueriesGenerator.STRUCTURAL_UNITS_PROPERTIES = ['id', 'name'];

// Test 3 : partition sur arborescence (multi-niveau sur 3 niveaux)

//def CORPUS_NAME = "LIVRETOPERA10TEXTES"

//PartitionQueriesGenerator.STRUCTURAL_UNITS = ['text', 'div1', 'div2'];

//PartitionQueriesGenerator.STRUCTURAL_UNITS_PROPERTIES = ['id', 'name', 'name'];

// Test 4 : partition sur arborescence (multi-niveau sur 4 niveaux)

// Ajouter le 'n' permet par exemple ici de trier les parties par ordre de scène car sinon le tri est problématique, ex : "SCENE II" passe avant "SCENE PREMIERE"

//def CORPUS_NAME = "LIVRETOPERA2"

//PartitionQueriesGenerator.STRUCTURAL_UNITS = ['text', 'div1', 'div2', 'div2'];

//PartitionQueriesGenerator.STRUCTURAL_UNITS_PROPERTIES = ['id', 'name', 'n', 'name'];

// Test 5 : partitions croisées (sur plusieurs propriétés d'une même structure)

//def CORPUS_NAME = "DISCOURS"

//PartitionQueriesGenerator.STRUCTURAL_UNITS = ['text', 'text'];

//PartitionQueriesGenerator.STRUCTURAL_UNITS_PROPERTIES = ['loc', 'type'];

// Tests

//def CORPUS_NAME = "LIVRETOPERA10TEXTES"

//PartitionQueriesGenerator.STRUCTURAL_UNITS = ['div1', 'sp'];

//PartitionQueriesGenerator.STRUCTURAL_UNITS_PROPERTIES = ['name', 'who'];

// Tests

//def CORPUS_NAME = "LIVRETOPERA10TEXTES"

//PartitionQueriesGenerator.STRUCTURAL_UNITS = ['div1'];

//PartitionQueriesGenerator.STRUCTURAL_UNITS_PROPERTIES = ['n'];

//PartitionQueriesGenerator.PART_NAMES_PREFIX = 'act_';

// *************************** Debug parameters ************************************************************

PartitionQueriesGenerator.DEBUG = 0; 	// If DEBUG != 0 then partition is not created,

										// script only outputs the created queries and part names strings in console

// *************************** End of parameters ************************************************************

// Running

def partition = PartitionQueriesGenerator.createPartition(CORPUS_NAME, SUBCORPUS_NAME);

// Refreshing the RCP component

if(partition != null)	{

	monitor.syncExec(new Runnable() {

			public void run() {

				CorporaView.refresh();

				CorporaView.expand(partition.getParent());

			}

		});

}

/**

 * Create a list of queries and part names regarding the structural units, structural units properties, structural units to ignore user defined lists and expand target value specified.

 * @author s

 *

 */

public class PartitionQueriesGenerator	{

	public static int DEBUG = 0;								// si DEBUG != 0, alors les requêtes sont affichées mais la partition n'est pas créée

	public static String PARTITION_NAME = '';

	public static String[] STRUCTURAL_UNITS = [];				// Liste des unités structurelles sur lesquelles effectuer la partition, ex: ['text', 'div1']

	public static String[] STRUCTURAL_UNITS_PROPERTIES = [];	// Propriétés des unités structurelles sur lesquelles effectuer la partition, ex : ['id', 'name']

	public static String[] STRUCTURAL_UNITS_TO_IGNORE = [];		// Structure à ignorer, ex. CQL : !speaker

	public static String PART_NAMES_PREFIX = '';

	public static String EXPAND_TARGET = null;					// Expand to target, englobe les empans jusqu'à la balise parente spécifiée. NOTE : Le expand entre en conflit avec les sections à ignorer.

																// Si la target est à un niveau supérieur aux balises à ignorer, il les remet dans liste de résultats CWB et elles ne sont donc pas ignorées

	public static ArrayList<String> queries = new ArrayList<String>();

	public static ArrayList<String> partNames = new ArrayList<String>();

	/**

	 * Init the generator and process.

	 * @param corpusName

	 */

	public static Partition createPartition(String corpusName, String subcorpusName)	{

		if(STRUCTURAL_UNITS.size() > 0 && STRUCTURAL_UNITS.size() == STRUCTURAL_UNITS_PROPERTIES.size())	{

			// TODO : Log

			println '**************************************************************************************************************'

			println 'Creating the queries on corpus "' + corpusName + "'" ;

			Corpus corpus = CorpusManager.getCorpusManager().getCorpus(corpusName);

			// Subcorpora

			if(subcorpusName != null)	{

				corpus = corpus.getSubcorpusByName(subcorpusName);

			}

			// Recursing through the corpus and subcorpus

			process(corpus, 0, '', '');

			// Finalizing the queries

			finalizeQueries();

			// TODO : Debug

			// Displaying the partition name

			println '';

			println 'PARTITION_NAME: ' + PartitionQueriesGenerator.PARTITION_NAME;

			// Displaying the queries

			println 'Queries (count = ' + PartitionQueriesGenerator.queries.size() + '):';

			for(query in PartitionQueriesGenerator.queries)	{

				println query;

			}

			// Displaying the part names

			println 'Partnames (count = ' + PartitionQueriesGenerator.partNames.size() + '):';

			for(partName in PartitionQueriesGenerator.partNames)	{

				print partName + ' / ';

			}

			// TODO : Log

			println 'Queries created.';

			// Creating the partition

			if(DEBUG == 0 && queries.size() == partNames.size()) {

				return corpus.createPartition(PARTITION_NAME, queries, partNames);

			}

		}

		else	{

			// TODO : Log

			println 'Structural units count or structural units properties count error.';

			return null

		}

	}

	/**

	 * Recurse through structural units and structural units properties of corpus and create the queries and the part names.

	 * @param corpus the corpus or subcorpus

	 * @param index the index for recursion

	 * @param tmpQuery the temporary query for creating subcorpus part

	 * @param tmpPartName the temporary part name of the subcorpus part

	 */

	protected static void process(Corpus corpus, int index, String tmpQuery, String tmpPartName)	{

		// End of array

		if(index >= STRUCTURAL_UNITS.size())	{

			queries.add(tmpQuery);

			partNames.add(PART_NAMES_PREFIX + tmpPartName);

			return;

		}

		StructuralUnit su = corpus.getStructuralUnit(STRUCTURAL_UNITS[index]);

		StructuralUnitProperty sup = su.getProperty(STRUCTURAL_UNITS_PROPERTIES[index]);

		// TODO : Log

		println ''

		if(index == 0)	{

			println 'Pocessing Structural Unit Property "' + sup.getFullName() + '" on mother corpus "' + corpus.getName() + '"';

		}

		else	{

			println 'Pocessing Structural Unit Property "' + sup.getFullName() + '" on subcorpus part "' + tmpPartName + '"';

		}

		println ''

		// Creating the queries parts for each structural units properties values

		//for (supValue in sup.getOrderedValues()) { // TODO : signaler bug Matthieu, on ne devrait pas être obligé de repasser le sous-corpus à la méthode car sup a déjà été créée depuis le sous-corpus ? getValues() bugge aussi

		for (supValue in sup.getOrderedValues(corpus)) {

			// TODO : Log

			println ''

			println 'Value "' + supValue + '"';

			println ''

			// Getting the subcorpus linked to the structural unit property value

			Subcorpus tmpSubcorpus = corpus.createSubcorpusWithQueryString(su, sup, supValue, "tmp" + UUID.randomUUID());

			// Partition conditions and part name separators

			String and = '';

			String underscore = '';

			if(tmpQuery != '')	{

				underscore = '_';

				and = ' & ';

			}

			process(tmpSubcorpus, index + 1, (tmpQuery + and + '_.' + sup.getFullName() + '="' + supValue + '"'), tmpPartName + underscore + supValue);

			// Deleting the temporary subcorpus

			// TODO : bug : cette méthode ne supprime pas le corpus sans doute car il faut que le sous-corpus ne contienne pas d'autres sous-corpus ? le delete() en revanche fonctionne.

//			corpus.dropSubcorpus(tmpSubcorpus);

			tmpSubcorpus.delete();

		}

	}

	/**

	 * 	Autoname the partition.

	 * @param partitionName

	 */

	protected static void autoNamePartition(String partitionName)	{

		// Structural units names and properties

		for(int i = 0; i < STRUCTURAL_UNITS.size(); i++)	{

			partitionName +=  STRUCTURAL_UNITS[i] + '_' + STRUCTURAL_UNITS_PROPERTIES[i] + '.';

		}

		// Structural units to ignore

		for(int i = 0; i < STRUCTURAL_UNITS_TO_IGNORE.size(); i++)	{

			partitionName +=  'NOT_' + STRUCTURAL_UNITS_TO_IGNORE[i] + '.';

		}

		// Removing last point in name

		PARTITION_NAME = partitionName.substring(0, partitionName.length() - 1);

	}

	/**

	 * Finalize the queries.

	 */

	protected static void finalizeQueries()	{

		String expandTo = '';

		// Expanding to user defined target

		if(EXPAND_TARGET != null && EXPAND_TARGET != '')	{

			expandTo = ' expand to ' + EXPAND_TARGET;

		}

		// Expanding to last child structural unit in user defined hierarchy

		else if(STRUCTURAL_UNITS_TO_IGNORE.size() == 0)	{

			expandTo = ' expand to ' + STRUCTURAL_UNITS[STRUCTURAL_UNITS.size() - 1];

		}

		// Autonaming the partition

		if(PARTITION_NAME == '')	{

			autoNamePartition(PARTITION_NAME);

			// Finalizing partition name

			PARTITION_NAME += expandTo.replace(' expand to', '.EXPAND TO').replace(' ', '_');

		}

		// Finalizing queries

		for(int j = 0; j < queries.size(); j++)	{

			String queryEnd = '';

			// Removing some sections

			for(sectionToIgnore in STRUCTURAL_UNITS_TO_IGNORE)	{

				queryEnd += ' & !' + sectionToIgnore;

			}

			queryEnd += ']' + expandTo;

			queries.set(j, '[' +  queries.get(j) + queryEnd);

		}

	}

}

/*

// Test dialogue de confirmation avant création de la partition

JFrame frame = new JFrame('test');

//frame.setMinimumSize(new Dimension(400, 400));

//frame.setVisible(true);

//frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

int n = JOptionPane.showConfirmDialog(

	frame, "Would you like green eggs and ham?",

	"An Inane Question",

	JOptionPane.YES_NO_OPTION);

if (n == JOptionPane.YES_OPTION) {

frame.setTitle("Ewww!");

} else if (n == JOptionPane.NO_OPTION) {

frame.setTitle("Me neither!");

} else {

frame.setTitle("Come on -- tell me!");

}*/

//// Récupération des unités structurelles et création de la liste des requêtes CQL

//int i = 0;

//ArrayList<String> queries = new ArrayList<String>();

//ArrayList<String> partNames = new ArrayList<String>();

//

//

//int currentQueriesCount;

//if(STRUCTURAL_UNITS.size() > 0 && STRUCTURAL_UNITS.size() == STRUCTURAL_UNITS_PROPERTIES.size())	{

//

//	// Parcours des unités strcuturelles à traiter

//	for (suName in STRUCTURAL_UNITS) {

//

//		// Définition auto du nom de partition

//		PARTITION_NAME += suName + '_';

//

//

//		StructuralUnit su = corpus.getStructuralUnit(suName);

//

//

//		// TODO : Debug

//		println ''

//		println 'Structural Unit Name: ' + su.getName();

//

//

//		// Récupération des propriétés d'unités structurelles

//		for (StructuralUnitProperty sup in su.getProperties())	{

//

//

//			if(STRUCTURAL_UNITS_PROPERTIES[i] != '' && sup.getName() == STRUCTURAL_UNITS_PROPERTIES[i])	{

//

//				// Définition auto du nom de partition

//				PARTITION_NAME += STRUCTURAL_UNITS_PROPERTIES[i] + ".";

//

//				// TODO : Debug

//				println "Structural Unit Property: " + sup.getName() + " ";

//

//

//				// Récupération des valeurs des propriétés d'unités structurelles

//

//				//for (supValue in sup.getOrderedValues()) {

//				for (supValue in sup.getOrderedValues()) {

//

//					// Récupération du sous-corpus lié à la valeur de propriété de structure

//					Subcorpus tmpSubcorpus = corpus.createSubcorpusWithQueryString(su, sup, supValue, "tmp");

//

//					String query = suName + '_' + STRUCTURAL_UNITS_PROPERTIES[i] + '="' + supValue + '"';

//

//

//					queries.add(query);

//					partNames.add(supValue);

//

//					// TODO : Debug

//					print supValue + " ";

//

//					// Suppression du sous-corpus temporaire

//					corpus.dropSubcorpus(tmpSubcorpus);

//

//				}

//

//			}

//		}

//

//

////		// Ajout des niveaux inférieurs

////		for(int i = 1; i < STRUCTURAL_UNITS.size(); i++)	{

////

////			for(int j = 0; j < queries.size(); j++)	{

////				queries.set(j, queries.get(j) + ' & _.' + STRUCTURAL_UNITS[i] + '_' + STRUCTURAL_UNITS_PROPERTIES[i] + '=".*"');

////

////				// Noms de partitions

////				partNames.set(j, partNames.get(j) + '_' + STRUCTURAL_UNITS[i] + '_'  + STRUCTURAL_UNITS_PROPERTIES[i]);

////			}

////		}

//

//

//

//

//

//

//		i++;

//	//	}

//	//	else	{

//	//

//	//	}

//

//	}

//

//

//

//

//

//	// Clôture des requêtes

//	for(int j = 0; j < queries.size(); j++)	{

//

//		String queryEnd = '';

//

//		// Suppression de sections

//		for(sectionToIgnore in STRUCTURAL_UNITS_TO_IGNORE)	{

//			queryEnd += ' & !' + sectionToIgnore;

//		}

//

//		queryEnd += ']';

//

//		// Expand to target

//		if(EXPAND_TARGET != null && EXPAND_TARGET != '')	{

//			queryEnd += ' expand to ' + EXPAND_TARGET;

//		}

//

//		queries.set(j, '[_.' +  queries.get(j) + queryEnd);

//	}

//}

////for (suName in STRUCTURAL_UNITS) {

//if(STRUCTURAL_UNITS.size() > 0 && STRUCTURAL_UNITS.size() == STRUCTURAL_UNITS_PROPERTIES.size())	{

//

//	suName = STRUCTURAL_UNITS[0]

//	//if(STRUCTURAL_UNITS.size() > 1)	{

//

//	// Définition auto du nom de partition

//	PARTITION_NAME += suName + '_';

//

//

//	// TODO : Debug

//	println ''

//	println "Structural Unit Name: $suName"

//

//	// Récupération des valeurs des propriétés d'unités structurelles

//	for (sup in discours.getStructuralUnitProperties(suName.asType(String)))	{

//

//		supName = STRUCTURAL_UNITS_PROPERTIES[0];

//

//		if(supName != '' && sup.getName() == supName)	{

//

//			// Définition auto du nom de partition

//			PARTITION_NAME += supName + ".";

//

//			// TODO : Debug

//			println "Structural Unit Property: " + supName + " ";

//

//			for (supValue in sup.getOrderedValues()) {

//

//				String query = '[_.' + suName + '_' + supName + '="' + supValue + '"';

//

//				// Suppression de sections

//				for(sectionToIgnore in STRUCTURAL_UNITS_TO_IGNORE)	{

//					query += ' & !' + sectionToIgnore;

//				}

//

//

//

//				queries.add(query);

//				partNames.add(supValue);

//

//				// TODO : Debug

//				print supValue + " ";

//			}

//		}

//	}

//

//

//	// Ajout des niveaux inférieurs

//	for(int i = 1; i < STRUCTURAL_UNITS.size(); i++)	{

//

//		for(int j = 0; j < queries.size(); j++)	{

//			queries.set(j, queries.get(j) + ' & _.' + STRUCTURAL_UNITS[i] + '_' + STRUCTURAL_UNITS_PROPERTIES[i] + '=".*"');

//

//			// Noms de partitions

//			partNames.set(j, partNames.get(j) + '_' + STRUCTURAL_UNITS[i] + '_'  + STRUCTURAL_UNITS_PROPERTIES[i]);

//		}

//	}

//

//

//	// Clôture des requêtes

//	for(int j = 0; j < queries.size(); j++)	{

//

//		String queryEnd = ']';

//

//		// Expand to target

//		if(EXPAND_TARGET != null && EXPAND_TARGET != '')	{

//			queryEnd += ' expand to ' + EXPAND_TARGET;

//		}

//

//		queries.set(j, queries.get(j) + queryEnd);

//	}

//

//

//

//	//i++;

////	}

////	else	{

////

////	}

//

////}

//}

// Fonctionnelle pour 1 niveau de hiérarchie

//// Récupération des unités structurelles et création de la liste des requêtes CQL

//int i = 0;

//String supName;

//ArrayList queries = new ArrayList();

//ArrayList partNames = new ArrayList();

//

//for (suName in STRUCTURAL_UNITS) {

//

//

//	// Définition auto du nom de partition

//	NAME += suName + '_';

//

//

//

//	println "Structural Unit Name: $suName"

//

//	// Récupération des valeurs des propriétés d'unités structurelles

//	for (sup in discours.getStructuralUnitProperties(suName.asType(String)))	{

//

//		supName = STRUCTURAL_UNITS_PROPERTIES[i];

//

//		if(supName != '' && sup.getName() == supName)	{

//

//			// Définition auto du nom de partition

//			NAME += supName + ".";

//

//			// TODO : Debug

//			println "Structural Unit Property: " + supName + " ";

//

//			for (supValue in sup.getOrderedValues()) {

//

//				String query = '[_.' + suName + '_' + supName + '="' + supValue + '"';

//

//				// Suppression de sections

//				for(sectionToIgnore in STRUCTURAL_UNITS_TO_IGNORE)	{

//					query += ' & !' + sectionToIgnore;

//				}

//

//				 query += ']';

//

//				// Expand to target

//				if(EXPAND_TARGET != null && EXPAND_TARGET != '')	{

//					query += ' expand to ' + EXPAND_TARGET;

//				}

//

//

//				queries.add(query);

//				partNames.add(supValue);

//

//				// TODO : Debug

//				print supValue + " ";

//			}

//		}

//	}

//	i++;

//}

//// start

//if (queries.size() == partnames.size()) {

////	def discours = CorpusManager.getCorpusManager().getCorpus(CORPUS)

//	def partition;

//	if (SUBCORPUS == null) {

//		println "partition build with $discours"

//		partition = discours.createPartition(NAME, queries.as, PARTNAMES)

//	} else {

//		def subcorpus

//		if (SUBCORPUSQUERY == null) {

//			println "partition build with subcorpus by name $SUBCORPUS"

//			subcorpus = discours.getSubcorpusByName(SUBCORPUS)

//			if (subcorpus == null) {

//				println "Error: SUBCORPUS NOT FOUND with name : $SUBCORPUS"

//			}

//		} else {

//			println "partition build with subcorpus with query $SUBCORPUSQUERY"

//			subcorpus = discours.createSubcorpus(new Query(SUBCORPUSQUERY), SUBCORPUS)

//		}

//		partition = subcorpus.createPartition(NAME, QUERIES, PARTNAMES)

//	}

//

//	def list = Arrays.asList(partition.getPartSizes())

//	println "Partition created $NAME: "+list+" parts"

//	// println "Total size: "+list.sum()+" - is equal to (sub)corpus size : "+(list.sum() == partition.getCorpus().getSize())

//    println "Total size: "+list.sum()+" - (sub)corpus size : "+(partition.getCorpus().getSize())

//

//	monitor.syncExec(new Runnable() {

//	public void run() {

//		CorporaView.refresh();

//		CorporaView.expand(partition.getParent());

//	}

//});

//} else {

//	println "QUERIES.size() != PARTNAMES.size() = "+QUERIES.size()+" != "+PARTNAMES.size()

//}

// parameters

//def CORPUS_NAME = "LIVRETOPERA10TEXTES"

////def SUBCORPUS = "NOMDUSOUSCORPUS"

//def SUBCORPUS = null // si partition sur corpus

////def SUBCORPUSQUERY = '"je" expand to s'

//def SUBCORPUSQUERY = null // si sous-corpus par nom

//def TEXT = "01_ACHILLE ET POLYXENE"

// def TEXT = "02_ZEPHIRE ET FLORE"

/*def QUERIES = [

'<lg>[_.text_id="' + TEXT + '" & _.div1_n="1" & _.sp_who=".*"]+</lg>',

'<lg>[_.text_id="' + TEXT + '" & _.div1_n="2" & _.sp_who=".*"]+</lg>',

'<lg>[_.text_id="' + TEXT + '" & _.div1_n="3" & _.sp_who=".*"]+</lg>',

'<lg>[_.text_id="' + TEXT + '" & _.div1_n="4" & _.sp_who=".*"]+</lg>',

'<lg>[_.text_id="' + TEXT + '" & _.div1_n="5" & _.sp_who=".*"]+</lg>',

]

def PARTNAMES = [

"acte_1",

"acte_2",

"acte_3",

"acte_4",

"acte_5",

]*/

package tests

import java.util.UUID;

import org.txm.Toolbox

import org.txm.searchengine.cqp.MemCqiClient

import org.txm.searchengine.cqp.MemCqiServer

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

import org.txm.functions.ReferencePattern

import org.txm.rcpapplication.views.*

import org.txm.searchengine.cqp.corpus.query.Query

// Debug

println "******************************** Starting ********************************************";

// Tests suite de requêtes directement sur le serveur et création manuelle du sous-corpus

// parameters

def CORPUS = "LIVRETOPERA10TEXTES"

//def SUBCORPUS = "NOMDUSOUSCORPUS"

// def SUBCORPUS = null // si partition sur corpus

//def SUBCORPUSQUERY = '"je" expand to s'

//def SUBCORPUSQUERY = null // si sous-corpus par nom

def discours = CorpusManager.getCorpusManager().getCorpus(CORPUS)

def subcorpusCqpId = 'S' + UUID.randomUUID().toString();

try {

	def server = (MemCqiServer)Toolbox.getCqiServer();

//	server.query('show corpora;');

//	server.query("info " + CORPUS + ";");

	server.query(CORPUS + ";");

	//client.query(SUBCORPUSQUERY);

	// Suppression de variable de résultats

//	server.query("discard A;");

//	server.query("discard B;");

//	server.query("discard C;");

//	server.query('C = /region[sp,a]::a.sp_who="IPHIS";');

// Test mono ligne : ne fonctionne pas en mode server

//	server.query('A = /region[sp]; B = /region[speaker]; C = difference B A;');

//	server.query('A = /region[sp];');

//	server.query('B = /region[speaker];');

//	server.query('C = difference A B;');

	// Tests options d'affichage

	server.query('show cd;');

	server.query('show +div1 +div2 +sp +lg +l +speaker;'); // Affichage des balises XML dans les listes de résultats

	//server.query('set ShowTagAttributes on;');

	// Tests

//	server.query('A = /region[sp,a]::a.sp_who="THALIE";');

//	server.query('B = /region[speaker];');

//	server.query(subcorpusCqpId + ' = diff A B;');

	//server.query(subcorpusCqpId + ' = B;');

//	server.query(subcorpusCqpId + ' = <sp>[(_.) != "speaker"]+</sp>;');

	//server.query(subcorpusCqpId + ' = <div1>[]*<sp>[]+</sp>[]*</div1>;');

	//server.query(subcorpusCqpId + ' = <div1>[!speaker]*</div1>;');

// server.query(subcorpusCqpId + ' = <lg>[_.div1_n=".*" & _.sp_who="THALIE"]+</lg>;');	

//	server.query(subcorpusCqpId + ' = /region[i];');

	// Tests de requête sur le sous-corpus créé

	//server.query('set MatchingStrategy shortest;'); // standard, shortest, longest, traditional

	//server.query(subcorpusCqpId + ' = [div1 & _.sp_who="THALIE" & !speaker];');

	//server.query(subcorpusCqpId + ' = [_.div1_name=".*" & !speaker];');

	//server.query(subcorpusCqpId + ' = [_.div1_name=".*" & !speaker] expand to lg;');

	server.query(subcorpusCqpId + ' = [div1 & !speaker] expand to lg;');

	//server.query('group ' + subcorpusCqpId + ' match word;');

	server.query(subcorpusCqpId + ';');

	//server.query(subcorpusCqpId + ' = [] !;');

	//server.query(subcorpusCqpId + ';');

	//server.query(subcorpusCqpId + ' = [] !;');

//	server.query(subcorpusCqpId + ' = [] expand to div1 & !speaker;');

	//server.query(subcorpusCqpId + ' = [div1 & !speaker];');

	//server.query(subcorpusCqpId + ' = [div1 & !speaker] expand to lg;');

	//server.query(subcorpusCqpId + ' = [div1 & !speaker] expand to lg;');

	//server.query(subcorpusCqpId + ' = [div1 & !speaker];');

	//server.query(subcorpusCqpId + ' = [div1 &_.sp_who="THALIE" & !speaker];');

	//server.query(subcorpusCqpId + ' = [div1 &_.sp_who="THALIE" & !speaker];');

	//server.query(subcorpusCqpId + ' = "fin" [];');

	//server.query(subcorpusCqpId + ' = [div1 & _.sp_who="THALIE" & !speaker];');

	// Affichage du sous-corpus

	//server.query("cat " + subcorpusCqpId + " 0 10;")

	server.query("cat " + subcorpusCqpId + ";")

	//server.cqpQuery(discours.getCqpId(), 'subcorpusid', SUBCORPUSQUERY);

	// Affichage des erreurs

	try {

		System.out.println("client.getLastCqiError() : "+server.getLastCqiError());

	} catch(Exception e) { System.out.println("Exception : "+e);}

	try {

		System.out.println("client.getLastCQPError() : "+server.getLastCQPError());

	} catch(Exception e) { System.out.println("Exception : "+e);}

	// Création manuelle du sous-corpus

//	Subcorpus subcorpus = new Subcorpus(subcorpusCqpId, "subcorpus" + subcorpusCqpId.toString().substring(0, 5), discours, new Query()); // FIXME : est-ce que cela pose un problème de passer une Query() vide ici ?

//	discours.subcorpora.add(subcorpus);

//	subcorpus.registerToParent();

	// Création manuelle d'une partition

//	subcorpus.createPartition(NAME, QUERIES, PARTNAMES)

}

 catch(Exception e) {

	  System.out.println("Exception : "+e);

  }

// Refresh de l'interface

monitor.syncExec(new Runnable() {

	public void run() {

		CorporaView.refresh();

		//CorporaView.expand(partition.getParent());

	}

});

//// parameters

//def CORPUS = "LIVRETOPERA10TEXTES"

////def SUBCORPUS = "NOMDUSOUSCORPUS"

//def SUBCORPUS = null // si partition sur corpus

////def SUBCORPUSQUERY = '"je" expand to s'

//def SUBCORPUSQUERY = null // si sous-corpus par nom

//

//

//

//// Liste des unités strcuturelles

////def HIERARCHY = ['text_id', 'div1_n', 'sp_who', 'lg'];

//def STRUCTURAL_UNITS = ['text', 'div1', 'sp'];

//def STRUCTURAL_UNITS_PROPERTIES = ['id', 'n', 'who'];

////def TARGET = 'lg';

//

//String NAME = '';

//def TEXT = "01_ACHILLE ET POLYXENE"

// def TEXT = "02_ZEPHIRE ET FLORE"

/*def QUERIES = [

'<lg>[_.text_id="' + TEXT + '" & _.div1_n="1" & _.sp_who=".*"]+</lg>',

'<lg>[_.text_id="' + TEXT + '" & _.div1_n="2" & _.sp_who=".*"]+</lg>',

'<lg>[_.text_id="' + TEXT + '" & _.div1_n="3" & _.sp_who=".*"]+</lg>',

'<lg>[_.text_id="' + TEXT + '" & _.div1_n="4" & _.sp_who=".*"]+</lg>',

'<lg>[_.text_id="' + TEXT + '" & _.div1_n="5" & _.sp_who=".*"]+</lg>',

]

def PARTNAMES = [

"acte_1",

"acte_2",

"acte_3",

"acte_4",

"acte_5",

]*/

//def discours = CorpusManager.getCorpusManager().getCorpus(CORPUS)

//

//

//// Récupération des unités structurelles

//def i = 0;

//def supName;

//def QUERIES;

//def query;

//

//for (suName in STRUCTURAL_UNITS) {

//

//

//	// Définition auto du nom de partition

//	NAME += suName + '_';

//

//	//query = '';

//	

//	

//	println "Structural Unit Name: $suName"

//	

//	// Récupération des valeurs des propriétés d'unités structurelles

//	for (sup in discours.getStructuralUnitProperties(suName.asType(String)))	{

//		

//		supName = STRUCTURAL_UNITS_PROPERTIES[i];

//		

//		if(supName != '' && sup.getName() == supName)	{

//			

//			// Définition auto du nom de partition

//			NAME += supName + ".";

//			

//			println "Structural Unit Property: $supName";

//			

//			for (supValue in sup.getOrderedValues()) {

//			

//				//query += '<' + TARGET + '>' + supName;

//				

//				

//				print "$supValue "

//			}

//		}

//	}

//	i++;

//}

//

//// Suppression du dernier underscore ou point

//NAME = NAME.substring(0, NAME.length() - 1);

//// Debug

//println "NAME: " + NAME;

// start

/*if (QUERIES.size() == PARTNAMES.size()) {

	def partition;

	// Test unités structurelles

	for (t in discours.getStructuralUnits()) {

		println "Structural Unit: $t"

		// Test propriétés d'unités structurelles

		for (g in discours.getStructuralUnitProperties(t.asType(String))) {

			println "\tStructural Unit Property: $g"

			// Test valeurs des propriétés d'unités structurelles

			for (h in g.getOrderedValues()) {

				print "$h, "

			}

		}

	}

	// Test propriétés

	for (t in discours.getProperties()) {

		println "Property: $t"

	}

	if (SUBCORPUS == null) {

		println "partition build with $discours"

		partition = discours.createPartition(NAME, QUERIES, PARTNAMES)

	} else {

		def subcorpus

		if (SUBCORPUSQUERY == null) {

			println "partition build with subcorpus by name $SUBCORPUS"

			subcorpus = discours.getSubcorpusByName(SUBCORPUS)

			if (subcorpus == null) {

				println "Error: SUBCORPUS NOT FOUND with name : $SUBCORPUS"

			}

		} else {

			println "partition build with subcorpus with query $SUBCORPUSQUERY"

			subcorpus = discours.createSubcorpus(new Query(SUBCORPUSQUERY), SUBCORPUS)

		}

		partition = subcorpus.createPartition(NAME, QUERIES, PARTNAMES)

	}

	def list = Arrays.asList(partition.getPartSizes())

	println "Partition created $NAME: "+list+" parts"

	// println "Total size: "+list.sum()+" - is equal to (sub)corpus size : "+(list.sum() == partition.getCorpus().getSize())

    println "Total size: "+list.sum()+" - (sub)corpus size : "+(partition.getCorpus().getSize())

	monitor.syncExec(new Runnable() {

	public void run() {

		CorporaView.refresh();

		CorporaView.expand(partition.getParent());

	}

});

} else {

	println "QUERIES.size() != PARTNAMES.size() = "+QUERIES.size()+" != "+PARTNAMES.size()

}*/

print(Progression5)

<html>

<body>

<p>Contains Groovy scripts used to manipulate SVN repositories</p>

</body>

</html>

// Copyright © 2010-2013 ENS de Lyon.

// Copyright © 2007-2010 ENS de Lyon, CNRS, INRP, University of

// Lyon 2, University of Franche-Comté, University of Nice

// Sophia Antipolis, University of Paris 3.

// 

// The TXM platform is free software: you can redistribute it

// and/or modify it under the terms of the GNU General Public

// License as published by the Free Software Foundation,

// either version 2 of the License, or (at your option) any

// later version.

// 

// The TXM platform is distributed in the hope that it will be

// useful, but WITHOUT ANY WARRANTY; without even the implied

// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR

// PURPOSE. See the GNU General Public License for more

// details.

// 

// You should have received a copy of the GNU General

// Public License along with the TXM platform. If not, see

// http://www.gnu.org/licenses.

// 

// 

// 

// $LastChangedDate: 2017-01-24 18:11:42 +0100 (Tue, 24 Jan 2017) $

// $LastChangedRevision: 3400 $

// $LastChangedBy: mdecorde $ 

//

package org.txm.scripts.tigersearch;

import java.text.DateFormat;

import java.util.Date;

import java.util.ArrayList;

import javax.xml.stream.*;

import java.net.URL;

import org.txm.importer.filters.*;

// TODO: Auto-generated Javadoc

/**

 * The Class InjectAnnotations.

 *

 * @author mdecorde

 * 

 * inject annotations into ONE file

 */

public class InjectAnnotations {

	/** The url. */

	private def url;

	/** The input data. */

	private def inputData;

	/** The factory. */

	private def factory;

	/** The parser. */

	private XMLStreamReader parser;

	/** The reader. */

	private Reader reader;

	/** The output. */

	private def output;

	/** The solotags. */

	ArrayList<String> solotags;

	/** The lespos. */

	HashSet<String> lespos = new HashSet<String>();

	/**

	 * Instantiates a new inject annotations.

	 *

	 * @param url the url

	 * @param annotations the annotations

	 * @param solotags the solotags

	 */

	public InjectAnnotations(URL url, File annotations,

			ArrayList<String> solotags) {

		try {

			this.url = url;

			this.solotags = solotags;

			inputData = url.openStream();

			factory = XMLInputFactory.newInstance();

			parser = factory.createXMLStreamReader(inputData);

			reader = new FileReader(annotations);

		} catch (XMLStreamException ex) {

			System.out.println(ex);

		} catch (IOException ex) {

			System.out.println("IOException while parsing ");

		}

	}

	/**

	 * Creates the output.

	 *

	 * @param outfile the outfile

	 * @return true, if successful

	 */

	private boolean createOutput(File outfile) {

		try {

			File f = outfile;

			output = new OutputStreamWriter(new FileOutputStream(f), "UTF-8");

			return true;

		} catch (Exception e) {

			System.out.println(e.getLocalizedMessage());

			return false;

		}

	}

	/**

	 * Gets the next annotation.

	 *

	 * @return the next annotation

	 */

	private String getNextAnnotation() {

		String line = reader.readLine();

		while (line.startsWith("<"))

			line = reader.readLine();

		lespos.add(line.split("\t")[1]);

		return line = line.split("\t")[1];

	}

	/**

	 * Process.

	 *

	 * @param outfile the outfile

	 * @return true, if successful

	 */

	public boolean process(File outfile) {

		if (createOutput(outfile)) {

			String lastopenlocalname = "";

			String localname = "";

			try {

				for (int event = parser.next(); event != XMLStreamConstants.END_DOCUMENT; event = parser

						.next()) {

					switch (event) {

					case XMLStreamConstants.START_ELEMENT:

						localname = parser.getLocalName();

						String prefix = parser.getPrefix();

						if (prefix == null || prefix == "")

							prefix = "";

						else

							prefix += ":";

						lastopenlocalname = localname;

						output.write("\n<" + prefix + localname);

						for (int i = 0; i < parser.getAttributeCount(); i++)

							output.write(" " + parser.getAttributeLocalName(i)

									+ "=\"" + parser.getAttributeValue(i)

									+ "\"");

						// get annotation

						if (localname.equals("t"))

							output.write(" pos=\"" + getNextAnnotation()

											+ "\"");

						if (solotags.contains(localname))

							output.write("/>");

						else

							output.write(">");

						break;

					case XMLStreamConstants.END_ELEMENT:

						localname = parser.getLocalName();

						String prefix = parser.getPrefix();

						if (prefix == null || prefix == "")

							prefix = "";

						else

							prefix += ":";

						switch (localname) {

						default:

							if (!solotags.contains(localname))

								if (lastopenlocalname.equals(localname))

									output.write("</" + prefix + localname

											+ ">");

								else

									output.write("\n</" + prefix + localname

											+ ">");

						}

						break;

					case XMLStreamConstants.CHARACTERS:

						output.write(parser.getText().trim());

						break;

					}

				}

				output.close();

				parser.close();

			} catch (XMLStreamException ex) {

				System.out.println(ex);

			} catch (IOException ex) {

				System.out.println("IOException while parsing " + inputData);

			}

		}

	}

	/**

	 * Gets the feature.

	 *

	 * @param f the f

	 * @return the feature

	 */

	public void getFeature(File f)

	{

		Writer writer = new OutputStreamWriter(new FileOutputStream(f) , "UTF-8");

		writer.write("<feature name=\"pos\" domain=\"T\">\n")

		for(String pos : lespos)

			writer.write("<value name=\""+pos+"\"></value>\n");

		writer.write("</feature>\n")

		writer.close();

	}

	/**

	 * The main method.

	 *

	 * @param args the arguments

	 */

	public static void main(String[] args) {

		String rootDir = "~/xml/beroul/";

		new File(rootDir + "/identity/").mkdir();

		ArrayList<String> milestones = new ArrayList<String>();// the tags who

		// you want them

		// to stay

		// milestones

		milestones.add("tagUsage");

		milestones.add("pb");

		milestones.add("lb");

		milestones.add("catRef");

		File srcfile = new File(rootDir, "beroul.xml");

		File annotationsfiles = new File(rootDir, "result.tt");

		File resultfile = new File(rootDir, "beroul-result.xml");

		println("identity file : " + srcfile + " to : " + resultfile);

		def builder = new InjectAnnotations(srcfile.toURL(), annotationsfiles,

				milestones);

		builder.process(resultfile);

		return;

	}

}

<html>

<body>

<p>Manage tigerSearch source file</p>

</body>

</html>

/**

 * Main.

 *

 * @param args the args

 */

// Copyright © 2010-2013 ENS de Lyon.

// Copyright © 2007-2010 ENS de Lyon, CNRS, INRP, University of

// Lyon 2, University of Franche-Comté, University of Nice

// Sophia Antipolis, University of Paris 3.

// 

// The TXM platform is free software: you can redistribute it

// and/or modify it under the terms of the GNU General Public

// License as published by the Free Software Foundation,

// either version 2 of the License, or (at your option) any

// later version.

// 

// The TXM platform is distributed in the hope that it will be

// useful, but WITHOUT ANY WARRANTY; without even the implied

// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR

// PURPOSE. See the GNU General Public License for more

// details.

// 

// You should have received a copy of the GNU General

// Public License along with the TXM platform. If not, see

// http://www.gnu.org/licenses.

// 

// 

// 

// $LastChangedDate: 2013-05-06 17:38:43 +0200 (lun., 06 mai 2013) $

// $LastChangedRevision: 2386 $

// $LastChangedBy: mdecorde $ 

//

package org.txm.scripts.tigersearch;

import org.txm.utils.treetagger.TreeTagger;

import org.txm.scripts.teitxm.*;

// TODO: Auto-generated Javadoc

/**

 * script to insert annotation into beroul file.

 *

 * @return the java.lang. object

 */

String home = System.getProperty("user.home")

File rootDir = new File(home, "xml/fullberoul/")

ArrayList<String> milestones = new ArrayList<String>();//the tags who you want them to stay milestones

milestones.add("tagUsage");

milestones.add("pb");

milestones.add("lb");

milestones.add("catRef");

//transform xml tiger >> TTsrc

File srcfile = new File(rootDir,"beroul.xml");

File resultfile = new File(rootDir,"beroul.tt");

println("xml>>TT from : "+srcfile+" to : "+resultfile );

def builder = new BuildTTFile(srcfile.toURL(), milestones);

builder.process(resultfile, "t");

//tag TT

String infile = resultfile;

String modelfile = home+"/treetagger/models/fro.par";

String outfile = rootDir.getAbsolutePath()+"/result.tt";

println("proj "+modelfile+ " on " +resultfile +" >> "+outfile);

TreeTagger tt = new TreeTagger(home+"/treetagger/bin/");

tt.settoken();

tt.setquiet();

tt.setsgml();

tt.seteostag("<s>");

tt.treetagger( modelfile, infile, outfile)

//inject new TTattributes

//File srcfile = new File(rootDir,"beroul.xml");

File annotationsfiles = new File(rootDir,"result.tt");

File lastresultfile = new File(rootDir,"beroul-result.xml");

println("insert TT annotations : "+srcfile+" to : "+resultfile );

builder = new InjectAnnotations(srcfile.toURL(),annotationsfiles, milestones);

builder.process(lastresultfile);

builder.getFeature(new File(rootDir,"feature.xml"));

/*

//TAG with TnT

//need to replace <s> by nothing and </s> by \n

String encoding = "UTF-8"

for(String text : texts)

{

	//patch src files

	File f = new File(textsDir,text+".t");

	File temp = new File("tempFileCVScleaner")

	println("patch texts files "+f+": rmv <s> and replace </s>");

	Reader reader = new InputStreamReader(new FileInputStream(f),encoding);

	Writer writer = new FileWriter(temp);

	reader.eachLine 

			{

				if(it.trim().startsWith("</s"))

					writer.write("\n")

				else if(it.trim().startsWith("<s"))

					writer.write("")

				else

					writer.write(it+"\n")

			}

	reader.close();

	writer.close();

	if (!(f.delete() && temp.renameTo(f))) println "Warning can't rename file "+temp+" to "+f

}*/

// Copyright © 2010-2013 ENS de Lyon.

// Copyright © 2007-2010 ENS de Lyon, CNRS, INRP, University of

// Lyon 2, University of Franche-Comté, University of Nice

// Sophia Antipolis, University of Paris 3.

// 

// The TXM platform is free software: you can redistribute it

// and/or modify it under the terms of the GNU General Public

// License as published by the Free Software Foundation,

// either version 2 of the License, or (at your option) any

// later version.

// 

// The TXM platform is distributed in the hope that it will be

// useful, but WITHOUT ANY WARRANTY; without even the implied

// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR

// PURPOSE. See the GNU General Public License for more

// details.

// 

// You should have received a copy of the GNU General

// Public License along with the TXM platform. If not, see

// http://www.gnu.org/licenses.

// 

// 

// 

// $LastChangedDate:$

// $LastChangedRevision:$

// $LastChangedBy:$ 

//

package org.txm.scripts.tigersearch;

import org.txm.sw.ReplaceXmlDomNode;

import java.io.File;

import java.util.ArrayList;