Laboratoire ICAR » Plateforme TXM

                  commandId="org.txm.annotation.urs.commands.LoadStructureFromGlozz"

                  commandId="org.txm.annotation.urs.commands.SaveCorpus"

                  commandId="org.txm.annotation.urs.commands.ExportGlozzCorpus"

                  commandId="org.txm.annotation.urs.commands.ExportTEICorpus"

                  style="push">

               <visibleWhen

                     checkEnabled="false">

                  <reference

                        definitionId="OneCorpusSelected">

                  </reference>

               </visibleWhen>

            </command>

            <command

package org.txm.macro.urs

import org.txm.annotation.urs.URSCorpora

import org.txm.searchengine.cqp.corpus.CQPCorpus

import visuAnalec.elements.*

// get the CQP corpus

if (!(corpusViewSelection instanceof CQPCorpus)) {

	println "Corpus view selection is no a corpus: $corpusViewSelection"

	return false;

}

def corpus = corpusViewSelection

// get the Analec corpus : stores the annotations and annotation structure

def analecCorpus = URSCorpora.getCorpus(corpus)

// get the annotations structure : stores the available annotation types, properties and values

def structure = analecCorpus.getStructure()

// get the annotations view : stores annotations and annotation structure display rules

def view = URSCorpora.getVue(corpus)

// set a default vue -> all is visible

view.retablirVueParDefaut()

// list the viewed types and properties

for (def type : view.getTypesAVoir(Unite.class)) {

	println "$type: "+view.getNomsChamps(Unite.class, type)

}

// manage the viewed&enabled type, properties ; the types and properties must be enabled to use the "view.setValeurChamp(TYPE, PROPERTY, VALUE)" method

view.ajouterType(Unite.class, "EXEMPLE")

view.ajouterProp(Unite.class, "EXEMPLE", "PEXEMPLE")

// display annotations per Element type (Unite, Relation, Schema) and per type

// Create annotation type

structure.ajouterType(Unite.class, "EXEMPLE");

//structure.ajouterType(Relation.class, "EXEMPLE");

//structure.ajouterType(Schema.class, "EXEMPLE");

println structure.getTypes(Unite.class)

// Create annotation property

structure.ajouterProp(Unite.class, "EXEMPLE", "PEXEMPLE")

println structure.getNomsProps(Unite.class, "EXEMPLE")

// Create annotation value

structure.ajouterVal(Unite.class, "EXEMPLE", "PEXEMPLE", "oui")

structure.ajouterVal(Unite.class, "EXEMPLE", "PEXEMPLE", "non")

// Create annotations

// Unite

def u = analecCorpus.addUniteSaisie("EXEMPLE", 0, 10, ["PEXEMPLE":"oui"])

def u2 = analecCorpus.addUniteSaisie("EXEMPLE", 12, 12, ["PEXEMPLE":"oui"])

println u

// Edit annotations

u.getProps()["PEXEMPLE"] = "non"

// Unit getters

println u.getDeb() // start of unit

println u.getFin() // end of unit

println u.getProp("EXEMPLE")

println u.getType()

// Relation

Relation relation = new Relation("REXEMPLE", u, u2)

relation.getProps().put("PEXEMPLE", "oui")

analecCorpus.addRelationLue(relation)  // add the new relation

// Schema

Schema schema = new Schema()

schema.type = "SEXEMPLE"

schema.props.put("PEXEMPLE", "oui")

schema.ajouter(u) // insert one unit

analecCorpus.addSchemaLu(schema)  // add the new schema

// Browse Units

println "Units:"

for (String type : structure.getUnites()) {

	def units = analecCorpus.getUnites(type)

	if (units.size() > 0) {

		println "	${units.size()} $type"

	}

}

// Browse Relations

println "Relations:"

for (String type : structure.getRelations()) {

	def relations = analecCorpus.getRelations(type)

	if (relations.size() > 0) {

		println "	${relations.size()} $type"

	}

}

// Browse Schemas

println "Schemas:"

for (String type : structure.getSchemas()) {

	def schemas = analecCorpus.getSchemas(type)

	if (schemas.size() > 0) {

		println "	${schemas.size()} $type"

	}

}

// URS selections

// select Schemas

def debug = 0 // 1 2 for more logs

def strict_inclusion = true

def position = 0

def minimum_schema_size = 1;

def maximum_schema_size = 10;

def schema_ursql = "SEXEMPLE"

def unit_ursql = "EXEMPLE@PEXEMPLE=oui"

def unit_type = "EXEMPLE" 

println AnalecUtils.selectSchemasInCorpus(debug, analecCorpus, corpus, schema_ursql, minimum_schema_size, maximum_schema_size, strict_inclusion)

// with URSQL

println AnalecUtils.filterElements(debug, analecCorpus.getUnites(unit_type), unit_ursql)

// with intersection with CQP corpus matches

println AnalecUtils.filterUniteByInclusion(debug, analecCorpus.getUnites(unit_type), corpus.getMatches(), strict_inclusion, position)

// by size

println AnalecUtils.filterBySize(analecCorpus.getSchemas(schema_ursql), minimum_schema_size, maximum_schema_size)

// Delete annotations

analecCorpus.supUnite(u)

analecCorpus.supUnite(u2)

analecCorpus.supRelation(relation)

analecCorpus.supSchema(schema)

// Delete annotation value

structure.supprimerVal(Unite.class, "EXEMPLE", "PEXEMPLE", "oui")

structure.supprimerVal(Unite.class, "EXEMPLE", "PEXEMPLE", "non")

// Delete annotation property

structure.supprimerProp(Unite.class, "EXEMPLE", "PEXEMPLE")

structure.supprimerProp(Relation.class, "REXEMPLE", "PEXEMPLE")

structure.supprimerProp(Schema.class, "SEXEMPLE", "PEXEMPLE")

// Delete annotation type

structure.supprimerType(Unite.class, "EXEMPLE");

structure.supprimerType(Relation.class, "REXEMPLE");

structure.supprimerType(Schema.class, "SEXEMPLE");

// Revert changes

//URSCorpora.revert(corpus);

// Save changes

//URSCorpora.saveCorpus(corpus)

CQI = Toolbox.getCqiClient()

import org.txm.analec.*

CQI = Toolbox.getCqiClient()

		println "creating "+units[i+1]+", "+units[i]

		int[] positions = null

	def Mention = CQI.cpos2Str(posProperty.getQualifiedName(), positions)

	def cat = testRules(positions, Mention)

@Field @Option(name="unitType", usage="", widget="String", required=true, def="MENTION")

def unitType

@Field @Option(name="refPropertyName", usage="", widget="String", required=true, def="REF")

def refPropertyName

if (!structure.getUnites().contains(unitType)) { // check if the structure contains the unitType units

	println "Error: corpus structure does not contains unit with name=$unitType"

if (!structure.getUniteProperties(unitType).contains(refPropertyName)) {

	println "Error: corpus structure does not contains property name=$unitType"

def units = analecCorpus.getUnites(unitType)

	def prop = unit.getProp(refPropertyName)

	def prop = unit.getProp(refPropertyName)

		unit.getProps().put(refPropertyName, name)

println "- $nModified units of type $unitType have been modified."

println "- $nIgnored units of type $unitType have not been modified.\n"

package org.txm.macro.urs.export

// @author: Bruno Oberlé

// v1.0.0 2017-08-28

/*

 Cette macro exporte le corpus sélectionné et ses annotations vers deux fichiers de format Glozz:

 - un fichier .ac contenant le corpus brut,

 - un fichier .aa contenant les annotations au format XML utilisé par Glozz.

 Le corpus sélectionné dans TXM devrait contenir une structure Analec avec au moins un type d'unité défini (e.g. MENTION, maillon, etc.). S'il n'y a pas de structure,

 ce n'est pas grave: le fichier est exporter, mais aucune annotation n'est créer. Cela permet d'exporter n'importe quel corpus au format Glozz.

 Pour exporter un texte au format Glozz *sans* les annotations qu'il contient, simplement mettre un unit_type qui n'existe pas (e.g. "foobar" au lieu de "MENTION").

 La macro ne produit pour l'instant pas automatiquement de modèle Glozz (fichier .aam).  Cela n'est pas un problème pour ouvrir le résultat dans Glozz ou Analec.

 */

// STANDARD DECLARATIONS

import org.apache.commons.lang.*

import org.kohsuke.args4j.*

import groovy.transform.*

import org.txm.*

import org.txm.rcp.swt.widget.parameters.*

import org.txm.annotation.urs.*

import org.txm.searchengine.cqp.*

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

import visuAnalec.Message.*

import visuAnalec.donnees.*

import visuAnalec.elements.*

import visuAnalec.vue.*

// CHECK CORPUS

if (!(corpusViewSelection instanceof MainCorpus)) {

	println "Corpora selection is not a MainCorpus: "+corpusViewSelection

	return;

}

// BEGINNING OF PARAMETERS

@Field @Option(name="unit_type",usage="", widget="String", required=true, def="MENTION")

		String unit_type

@Field @Option(name="filename",usage="", widget="String", required=true, def="filename without extension (.ac/.aa)")

		String filename

if (!ParametersDialog.open(this)) return;

// VARIABLES

corpus = corpusViewSelection

doExport(corpus, unit_type, filename)

public void doExport(MainCorpus corpus, String unit_type, String filename) {

	size = corpus.getSize() // you may also use: corpus.getTextEndLimits() (= index of last token = size-1)

	CQI = CQPSearchEngine.getCqiClient()

	word = corpus.getWordProperty()

	// note: using "lbn" seems to work better than "pn" (some imported corpora are missing this information)

	//pn = corpus.getProperty("pn")

	//if (pn == null) pn = corpus.getProperty("div")

	pn = corpus.getProperty("lbn")

	// BUILD THE RAW TEXT, THE POSITIONS AND FIND THE PARAGRAPHS

	rawText = "" // the corpus for the .ac file

	positions = [] // each element is an array [start, end] indicating the position in the rawText

	pnCount = 0 // the par counter, used for indexing the pns array

	lastPn = -1 // the last paragraph number

	pns = [] // each element is an array [start, end] representing the start and end of the paragraph in the rawText

	for (def i=0; i<size; i++) {

		f = CQI.cpos2Str(word.getQualifiedName(), (int[])[i])[0]

		if (pn == null) {

			p = 1

		} else {

			p = CQI.cpos2Str(pn.getQualifiedName(), (int[])[i])[0]

		}

		start = rawText.length()

		rawText += f

		if (lastPn != p) {

			pnCount++;

			if (pnCount > 1) {

				pns[pnCount-2][1] = end

			}

			pns[pnCount-1] = [start, 0]

		}

		lastPn = p

		end = rawText.length() // must be after setting it up in pns!

		if (i != size-1) rawText += " "

		positions[i] = [start, end]

	}

	pns[pnCount-1][1] = end

	println pnCount + " paragraph(s) found."

	// CORPUS ANALEC (GET THE ANNOTATIONS)

	// note that unit_type has been defined with an option of the dialog at the beginning

	def analecCorpus = URSCorpora.getCorpus(corpus);

	// list of properties

	struct = analecCorpus.getStructure();

	propertyList = struct.getUniteProperties(unit_type);

	// export to file (corpus)

	corpusFilename = filename + ".ac";

	def corpusFile = new File(corpusFilename);

	corpusFile.write(rawText)

	println("Corpus written to `"+corpusFilename+"'.");

	// export to file (annotations)

	annotFilename = filename + ".aa";

	def annotFile = new File(annotFilename)

	annotFile.write("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n<annotations>\n")

		// erase (if you use << you don't erase!)

	def counter = 0

	// export paragraphs

	for (def i=0; i<pns.size(); i++) {

		def start = pns[i][0]

		def end = pns[i][1]

		annotFile << "<unit id=\"me_"+counter+"\">\n";

		annotFile << "<metadata><author>me</author><creation-date>"+counter+"</creation-date></metadata>\n";

		annotFile << "<characterisation><type>paragraph</type><featureSet /></characterisation>\n";

		annotFile << "<positioning><start><singlePosition index=\""+start+"\" /></start><end><singlePosition index=\""+end+"\" /></end></positioning>\n";

		annotFile << "</unit>\n";

		counter++;

	}

	// export units

	def units = analecCorpus.getUnites(unit_type);

	//units.sort() { a, b -> a.getDeb() <=> b.getDeb() ?: a.getFin() <=> b.getFin() };

	def unitCount = 0

	for (Unite unit : units) {

		unitCount++;

		annotFile << "<unit id=\"me_"+counter+"\">\n";

		annotFile << "<metadata><author>me</author><creation-date>"+counter+"</creation-date></metadata>\n";

		annotFile << "<characterisation>\n";

		annotFile << "<type>"+unit_type+"</type>\n";

		annotFile << "<featureSet>\n";

		for (String propertyName : propertyList) {

			annotFile << "<feature name=\""+propertyName+"\">"+unit.getProp(propertyName)+"</feature>\n";

		}

		annotFile << "</featureSet>\n";

		annotFile << "</characterisation>\n";

		start = positions[unit.getDeb()][0]

		end = positions[unit.getFin()][1]

		annotFile << "<positioning><start><singlePosition index=\""+start+"\" /></start><end><singlePosition index=\""+end+"\" /></end></positioning>\n";

		annotFile << "</unit>\n";

		counter++;

	}

	annotFile << "</annotations>\n";

	println unitCount + " unit(s) found."

	println("Annotations written to `"+annotFilename+"'.");

}

package org.txm.macro.urs.export

// @author: Bruno Oberle

// v1.1.0 2017-10-25:

//  - using the "p" structural unit if available to get paragraphs

//  - no space before comma, parenthesis, full stop, hyphen, etc.

//  - no space after hyphen, parenthesis, apostrophe, etc.

// v1.0.0 2017-08-28

/*

 Cette macro exporte le corpus sélectionné et ses annotations vers deux fichiers de format Glozz:

 - un fichier .ac contenant le corpus brut,

 - un fichier .aa contenant les annotations au format XML utilisé par Glozz.

 Le corpus sélectionné dans TXM devrait contenir une structure Analec avec au moins un type d'unité défini (e.g. MENTION, maillon, etc.). S'il n'y a pas de structure,

 ce n'est pas grave: le fichier est exporter, mais aucune annotation n'est créer. Cela permet d'exporter n'importe quel corpus au format Glozz.

 Pour exporter un texte au format Glozz *sans* les annotations qu'il contient, simplement mettre un unit_type qui n'existe pas (e.g. "foobar" au lieu de "MENTION").

 La macro ne produit pour l'instant pas automatiquement de modèle Glozz (fichier .aam).  Cela n'est pas un problème pour ouvrir le résultat dans Glozz ou Analec.

 */

// STANDARD DECLARATIONS

import org.apache.commons.lang.*

import org.kohsuke.args4j.*

import groovy.transform.*

import org.txm.*

import org.txm.rcp.swt.widget.parameters.*

import org.txm.annotation.urs.*

import org.txm.searchengine.cqp.*

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

import visuAnalec.Message.*

import visuAnalec.donnees.*

import visuAnalec.elements.*

import visuAnalec.vue.*

// GLOBAL VARIABLES

corpus = corpusViewSelection

CQI = CQPSearchEngine.getCqiClient()

// CHECK CORPUS

if (!(corpusViewSelection instanceof MainCorpus)) {

	println "Corpora selection is not a MainCorpus: "+corpusViewSelection

	return;

}

// PARAGRAPH AS STRUCTURAL UNIT?

/* note: some text have a structural unit called "p", which represents a paragraph.

   If this structural unit is present, we use it.  Otherwise we ask the user (the

   best way is to use the "pn" (paragraph number) or "lbn" (line number) property),

   depending on what is available in the corpus. If the user give not property name,

   we only define one paragraph for the whole text. */

parUnit = corpus.getStructuralUnit("p")

// BEGINNING OF PARAMETERS

@Field @Option(name="unit_type",usage="", widget="String", required=true, def="MENTION")

		String unit_type

@Field @Option(name="filename",usage="", widget="String", required=true, def="filename without extension (.ac/.aa)")

		String filename

if (!parUnit) {

	@Field @Option(name="par_prop",usage="the property used to compute paragraphs", widget="String", required=false, def="lbn")

		String par_prop

}

if (!ParametersDialog.open(this)) return;

// what paragraph unit to use?

pn = null

if (!parUnit && !par_prop.equals("")) {

	pn = corpus.getProperty(par_prop)

	if (!pn) {

		println "Error: I can't find a the property `$par_prop'."

		return

	}

}

/*********************************/

doExport(corpus, unit_type, filename)

public void doExport(MainCorpus corpus, String unit_type, String filename) {

	size = corpus.getSize() // you may also use: corpus.getTextEndLimits() (= index of last token = size-1)

	word = corpus.getWordProperty()

	// BUILD THE RAW TEXT, THE POSITIONS AND FIND THE PARAGRAPHS

	rawText = "" // the corpus for the .ac file

	positions = [] // each element is an array [start, end] indicating the position in the rawText

	pnCount = 0 // the par counter, used for indexing the pars array

	lastPn = -1 // the last paragraph number

	pars = [] // each element is an array [start, end] representing the start and end of the paragraph in the rawText

	insertSpace = true

	for (def i=0; i<size; i++) {

		f = CQI.cpos2Str(word.getQualifiedName(), (int[])[i])[0]

		if (parUnit) {

			p = CQI.cpos2Struc(parUnit.getQualifiedName(), (int[])[i])[0]

		} else if (pn == null) {

			p = 1

		} else {

			p = CQI.cpos2Str(pn.getQualifiedName(), (int[])[i])[0]

		}

		if (i > 0 && insertSpace

				&& !f.equals(".") && !f.equals(",") && !f.equals("'") && !f.equals("’") && !f.equals("-")

				&& !f.equals(")") && !f.equals("]") && !f.startsWith("-")) {

			rawText += " "

		}

		insertSpace = true // reset

		if (f.equals("-") || f.equals("[") || f.equals("(")

				|| f.endsWith("-") || f.endsWith("'") || f.endsWith("’") || f.endsWith("-")) {

			insertSpace = false

		}

		start = rawText.length()

		rawText += f

		if (lastPn != p) {

			pnCount++;

			if (pnCount > 1) {

				pars[pnCount-2][1] = end

			}

			pars[pnCount-1] = [start, 0]

		}

		lastPn = p

		end = rawText.length() // must be after setting it up in pars!

		positions[i] = [start, end]

	}

	pars[pnCount-1][1] = end

	println pnCount + " paragraph(s) found."

	// CORPUS ANALEC (GET THE ANNOTATIONS)

	// note that unit_type has been defined with an option of the dialog at the beginning

	def analecCorpus = URSCorpora.getCorpus(corpus);

	// list of properties

	struct = analecCorpus.getStructure();

	propertyList = struct.getUniteProperties(unit_type);

	// export to file (corpus)

	corpusFilename = filename + ".ac";

	def corpusFile = new File(corpusFilename);

	corpusFile.write(rawText)

	println("Corpus written to `"+corpusFilename+"'.");

	// export to file (annotations)

	annotFilename = filename + ".aa";

	def annotFile = new File(annotFilename)

	annotFile.write("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n<annotations>\n")

		// erase (if you use << you don't erase!)

	def counter = 0

	// export paragraphs

	for (def i=0; i<pars.size(); i++) {

		def start = pars[i][0]

		def end = pars[i][1]

		annotFile << "<unit id=\"me_"+counter+"\">\n";

		annotFile << "<metadata><author>me</author><creation-date>"+counter+"</creation-date></metadata>\n";

		annotFile << "<characterisation><type>paragraph</type><featureSet /></characterisation>\n";

		annotFile << "<positioning><start><singlePosition index=\""+start+"\" /></start><end><singlePosition index=\""+end+"\" /></end></positioning>\n";

		annotFile << "</unit>\n";

		counter++;

	}

	// export units

	def units = analecCorpus.getUnites(unit_type);

	//units.sort() { a, b -> a.getDeb() <=> b.getDeb() ?: a.getFin() <=> b.getFin() };

	def unitCount = 0

	for (Unite unit : units) {

		unitCount++;

		annotFile << "<unit id=\"me_"+counter+"\">\n";

		annotFile << "<metadata><author>me</author><creation-date>"+counter+"</creation-date></metadata>\n";

		annotFile << "<characterisation>\n";

		annotFile << "<type>"+unit_type+"</type>\n";

		annotFile << "<featureSet>\n";

		for (String propertyName : propertyList) {

			annotFile << "<feature name=\""+propertyName+"\">"+unit.getProp(propertyName)+"</feature>\n";

		}

		annotFile << "</featureSet>\n";

		annotFile << "</characterisation>\n";

		start = positions[unit.getDeb()][0]

		end = positions[unit.getFin()][1]

		annotFile << "<positioning><start><singlePosition index=\""+start+"\" /></start><end><singlePosition index=\""+end+"\" /></end></positioning>\n";

		annotFile << "</unit>\n";

		counter++;

	}

	annotFile << "</annotations>\n";

	println unitCount + " unit(s) found."

	println("Annotations written to `"+annotFilename+"'.");

}

package org.txm.macro.urs.export

// @author: Bruno Oberlé

// v1.0.0 2017-08-28

/*

 Cette macro exporte le corpus sélectionné et ses annotations vers deux fichiers de format Glozz:

 - un fichier .ac contenant le corpus brut,

 - un fichier .aa contenant les annotations au format XML utilisé par Glozz.

 Le corpus sélectionné dans TXM devrait contenir une structure Analec avec au moins un type d'unité défini (e.g. MENTION, maillon, etc.). S'il n'y a pas de structure,

 ce n'est pas grave: le fichier est exporter, mais aucune annotation n'est créer. Cela permet d'exporter n'importe quel corpus au format Glozz.

 Pour exporter un texte au format Glozz *sans* les annotations qu'il contient, simplement mettre un unit_type qui n'existe pas (e.g. "foobar" au lieu de "MENTION").

 La macro ne produit pour l'instant pas automatiquement de modèle Glozz (fichier .aam).  Cela n'est pas un problème pour ouvrir le résultat dans Glozz ou Analec.

 */

// STANDARD DECLARATIONS

import org.apache.commons.lang.*

import org.kohsuke.args4j.*

import groovy.transform.*

import org.txm.*

import org.txm.rcp.swt.widget.parameters.*

import org.txm.annotation.urs.*

import org.txm.searchengine.cqp.*

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

import visuAnalec.Message.*

import visuAnalec.donnees.*

import visuAnalec.elements.*

import visuAnalec.vue.*

// CHECK CORPUS

if (!(corpusViewSelection instanceof MainCorpus)) {

	println "Corpora selection is not a MainCorpus: "+corpusViewSelection

	return;

}

// BEGINNING OF PARAMETERS

@Field @Option(name="unit_type",usage="", widget="String", required=true, def="MENTION")

		String unit_type

@Field @Option(name="filename",usage="", widget="String", required=true, def="filename without extension (.ac/.aa)")

		String filename

if (!ParametersDialog.open(this)) return;

// VARIABLES

corpus = corpusViewSelection

doExport(corpus, unit_type, filename)

public void doExport(MainCorpus corpus, String unit_type, String filename) {

	size = corpus.getSize() // you may also use: corpus.getTextEndLimits() (= index of last token = size-1)

	CQI = CQPSearchEngine.getCqiClient()

	word = corpus.getWordProperty()

	// note: using "lbn" seems to work better than "pn" (some imported corpora are missing this information)

	//pn = corpus.getProperty("pn")

	//if (pn == null) pn = corpus.getProperty("div")

	pn = corpus.getProperty("lbn")

	// BUILD THE RAW TEXT, THE POSITIONS AND FIND THE PARAGRAPHS

	rawText = "" // the corpus for the .ac file

	positions = [] // each element is an array [start, end] indicating the position in the rawText

	pnCount = 0 // the par counter, used for indexing the pns array

	lastPn = -1 // the last paragraph number

	pns = [] // each element is an array [start, end] representing the start and end of the paragraph in the rawText

	for (def i=0; i<size; i++) {

		f = CQI.cpos2Str(word.getQualifiedName(), (int[])[i])[0]

		if (pn == null) {

			p = 1

		} else {

			p = CQI.cpos2Str(pn.getQualifiedName(), (int[])[i])[0]

		}

		start = rawText.length()

		rawText += f

		if (lastPn != p) {

			pnCount++;

			if (pnCount > 1) {

				pns[pnCount-2][1] = end

			}

			pns[pnCount-1] = [start, 0]

		}

		lastPn = p

		end = rawText.length() // must be after setting it up in pns!

		if (i != size-1) rawText += " "

		positions[i] = [start, end]

	}

	pns[pnCount-1][1] = end

	println pnCount + " paragraph(s) found."

	// CORPUS ANALEC (GET THE ANNOTATIONS)

	// note that unit_type has been defined with an option of the dialog at the beginning

	def analecCorpus = URSCorpora.getCorpus(corpus);

	// list of properties

	struct = analecCorpus.getStructure();

	propertyList = struct.getUniteProperties(unit_type);

	// export to file (corpus)

	corpusFilename = filename + ".ac";

	def corpusFile = new File(corpusFilename);

	corpusFile.write(rawText)

	println("Corpus written to `"+corpusFilename+"'.");

	// export to file (annotations)

	annotFilename = filename + ".aa";

	def annotFile = new File(annotFilename)

	annotFile.write("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n<annotations>\n") // erase

	def counter = 0

	// export paragraphs

	for (def i=0; i<pns.size(); i++) {

		def start = pns[i][0]

		def end = pns[i][1]

		annotFile << "<unit id=\"me_"+counter+"\">\n";

		annotFile << "<metadata><author>me</author><creation-date>"+counter+"</creation-date></metadata>\n";

		annotFile << "<characterisation><type>paragraph</type><featureSet /></characterisation>\n";

		annotFile << "<positioning><start><singlePosition index=\""+start+"\" /></start><end><singlePosition index=\""+end+"\" /></end></positioning>\n";

		annotFile << "</unit>\n";

		counter++;

	}

	// export units

	def units = analecCorpus.getUnites(unit_type);

	//units.sort() { a, b -> a.getDeb() <=> b.getDeb() ?: a.getFin() <=> b.getFin() };

	def unitCount = 0

	for (Unite unit : units) {

		unitCount++;

		annotFile << "<unit id=\"me_"+counter+"\">\n";

		annotFile << "<metadata><author>me</author><creation-date>"+counter+"</creation-date></metadata>\n";

		annotFile << "<characterisation>\n";

		annotFile << "<type>"+unit_type+"</type>\n";

		annotFile << "<featureSet>\n";

		for (String propertyName : propertyList) {

			annotFile << "<feature name=\""+propertyName+"\">"+unit.getProp(propertyName)+"</feature>\n";

		}

		annotFile << "</featureSet>\n";

		annotFile << "</characterisation>\n";

		start = positions[unit.getDeb()][0]

		end = positions[unit.getFin()][1]

		annotFile << "<positioning><start><singlePosition index=\""+start+"\" /></start><end><singlePosition index=\""+end+"\" /></end></positioning>\n";

		annotFile << "</unit>\n";

		counter++;

	}

	annotFile << "</annotations>\n";

	println unitCount + " unit(s) found."

	println("Annotations written to `"+annotFilename+"'.");

}

// Copyright © 2016 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

// @author sheiden

// STANDARD DECLARATIONS

package org.txm.macro.urs.export

import groovy.transform.Field

import org.jfree.chart.JFreeChart

import org.kohsuke.args4j.*

import org.txm.Toolbox

import org.txm.annotation.urs.*

import org.txm.macro.urs.AnalecUtils

import org.txm.rcp.Application

import org.txm.rcp.IImageKeys

import org.txm.rcp.swt.widget.parameters.*

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

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

import org.txm.utils.io.FileCopy;

import org.txm.utils.io.IOUtils

import org.txm.utils.zip.Zip

import visuAnalec.elements.*

def scriptName = this.class.getSimpleName()

if (!(corpusViewSelection instanceof MainCorpus)) {

	println "** $scriptName please select a MainCorpus to run the macro"

	return;

}

@Field @Option(name="new_name", usage="Corpus name in uppercase", widget="String", required=true, def="CORPUSNAME")

String new_name

if (!ParametersDialog.open(this)) return

new_name = new_name.toUpperCase()

def pattern = "[A-Z][-A-Z0-9]{1,20}"

if (!new_name.matches(pattern)) {

	println "New corpus name not conformant to CQP corpus name: "+pattern

	return false

}

MainCorpus mainCorpus = corpusViewSelection.getMainCorpus()

String name = mainCorpus.getName()

if (mainCorpus.isModified()) {

	println "Selected corpus is not saved. Aborting"

	return false

}

visuAnalec.donnees.Corpus analecCorpus = URSCorpora.getCorpus(mainCorpus)

if (analecCorpus.isModifie()) {

	println "Selected Analec corpus is not saved. Aborting"

	return false

}

File binDirectory = mainCorpus.getProjectDirectory()

String binName = binDirectory.getName()

File newBinDirectory = new File(binDirectory.getParentFile(), new_name)

if (newBinDirectory.exists()) {

	println "The new corpus directory already exists: $newBinDirectory. Aborting."

	return false

}

FileCopy.copyFiles(binDirectory, newBinDirectory)

if (!newBinDirectory.exists()) {

	println "Fail to copy binary directory $binDirectory to $newBinDirectory"

	return

}

File ecFile = new File(newBinDirectory, "analec/${name}.ec")

File ecvFile = new File(newBinDirectory, "analec/${name}.ecv")

File cssFile = new File(newBinDirectory, "css/${name}.css")

File dataFile = new File(newBinDirectory, "data/${name}")

File htmlFile = new File(newBinDirectory, "HTML/${name}")

File defaultCSSFile = new File(newBinDirectory, "HTML/${name}/default/css/${name}.css")

File registryFile = new File(newBinDirectory, "registry/${name.toLowerCase()}")

File txmFile = new File(newBinDirectory, "txm/${name}")

File ecFile2 = new File(newBinDirectory, "analec/${new_name}.ec")

File ecvFile2 = new File(newBinDirectory, "analec/${new_name}.ecv")

File cssFile2 = new File(newBinDirectory, "css/${new_name}.css")

File dataFile2 = new File(newBinDirectory, "data/${new_name}")

File htmlFile2 = new File(newBinDirectory, "HTML/${new_name}")

File defaultCSSFile2 = new File(newBinDirectory, "HTML/${new_name}/default/css/${new_name}.css")

File registryFile2 = new File(newBinDirectory, "registry/${new_name.toLowerCase()}")

File txmFile2 = new File(newBinDirectory, "txm/${new_name}")

println "renaming $ecFile : "+ecFile.renameTo(ecFile2)

println "renaming $ecvFile : "+ecvFile.renameTo(ecvFile2)

println "renaming $cssFile : "+cssFile.renameTo(cssFile2)

println "renaming $dataFile : "+dataFile.renameTo(dataFile2)

println "renaming $htmlFile : "+htmlFile.renameTo(htmlFile2)

println "renaming $defaultCSSFile : "+defaultCSSFile.renameTo(defaultCSSFile2)

println "renaming $registryFile : "+registryFile.renameTo(registryFile2)

println "renaming $txmFile : "+txmFile.renameTo(txmFile2)

// patch name in settings

println "replacing old name $name ->  ${new_name} in preferences"

File settingsDirectory = new File(newBinDirectory, ".settings")

for (File prefFile : settingsDirectory.listFiles()) {

	IOUtils.write(prefFile, prefFile.getText().replace(name, new_name))

}

File projectSetting = new File(newBinDirectory, ".project")

IOUtils.write(projectSetting, projectSetting.getText().replace(name, new_name))

// patch registry

String oldcontent = registryFile2.getText();

content = oldcontent.replace(name, new_name)

content = content.replace(name.toLowerCase(), new_name.toLowerCase())

registryFile2.withWriter { writer -> 

	writer.write(content)

}

File zipFile = new File(newBinDirectory.getAbsolutePath()+".txm")

Zip.compress(newBinDirectory, zipFile, monitor)

if (!zipFile.exists()) {

	println "Fail to zip binary directory $binDirectory to $zipFile"

	return

} else {

	println "Done: $zipFile"

}