9 Utilitaires et macros

La plateforme TXM peut être pilotée par macros. Ces macros peuvent réaliser des calculs relatifs à la méthode textométrique appliqués à des corpus existants ou bien réaliser n’importe quel traitement annexe. Par exemple aider à préparer les fichiers sources d’un corpus à importer en renommant les fichiers, en les convertissant dans d’autres formats, etc. ou encore exécuter un script R pour réaliser un calcul statistique non accessible depuis l’interface de TXM.

Le logiciel TXM est livré avec un ensemble de macros prédéfinies organisées sous la forme d’une bibliothèque d’utilitaires. Les utilitaires sont des macros utilisées régulièrement et publiées dans la bibliothèque de TXM. Dans la suite de ce manuel, les termes de macro et d’utilitaire sont synonymes.

9.1 Piloter par macros Groovy

Les macros sont des scripts Groovy[62] dont les paramètres peuvent être saisis dans une boite de dialogue ou bien sélectionnés au préalable depuis l’interface utilisateur de TXM (une icone de corpus ou de sous-corpus, ou toute autre icone de résultat de la vue Corpus).

C’est une façon pratique de faire exécuter un script par TXM sans avoir besoin de connaissances du langage de programmation Groovy (sans avoir à lire le code du script).

Différentes macros sont disponibles :

des macros livrées avec TXM et accessibles par le menu principal « Utilitaires » ou depuis la vue « Macro » voir la section 8.2 page 187 ;
des macros complémentaires téléchargeables depuis le site du logiciel TXM sur Sourceforge : http://sourceforge.net/projects/txm/files/software/TXM%20macros (ce dossier contient les versions les plus à jour des macros de TXM)
des macros de la communauté des utilisateurs de TXM recensées dans le wiki https://groupes.renater.fr/wiki/txm-users/public/macros.

9.1.1 Exécuter un utilitaire ou une macro

Les utilitaires ou macros se lancent à partir du menu principal « Utilitaires » ou depuis la vue « Macro », ouverte à partir du menu « Affichage > Vues > Macro », en double-cliquant sur leur icône ou bien avec le raccourcis clavier « F12 » pour exécuter la dernière macro exécutée.

On fournit des paramètres à une macro par deux moyens complémentaires :

avant de la lancer : en sélectionnant au préalable un ou plusieurs objets dans l’interface de TXM (corpus, sous-corpus, lexique, index, caractères dans un éditeur de texte, lignes de concordance, etc.) ;
au lancement : en renseignant les valeurs de paramètres dans la boite de dialogue de saisie des paramètres qui s’ouvre.

Les paramètres et la façon de les renseigner dépendent de chaque macro, par exemple un corpus, une chaine de caractères, un dossier contenant des fichiers à traiter, un fichier de sortie pour des résultats, etc.

Les valeurs des paramètres saisies dans la boite de dialogue sont mémorisées entre chaque appel d’une macro. Cette mémorisation s’appuie sur des fichiers d’extension « .properties » situés dans le même dossier que celui du fichier de la macro (visible dans la vue « Fichier » de TXM ou depuis le navigateur de fichier du système d’exploitation) situé à partir du dossier $TXMHOME/scripts/macro. La suppression du fichier « .properties » d’une macro supprime les valeurs de paramètres mémorisées, la macro utilisera les valeurs par défaut définies dans le script. L’édition du fichier « .properties » permet d’éditer les valeurs par défaut de ces paramètres.

L’exécution de la macro est terminée quand le message « Terminé : » s’affiche dans la console suivi de son temps d’exécution en millisecondes.

Les résultats des macros sont très variables, comme pour les commandes TXM (nouveau sous-corpus ou concordance, nouveaux fichiers, messages dans la console, etc.).

9.1.2 Installer une macro (ou un utilitaire)

Pour installer une macro, lancer la commande « Utilitaires > Add Macro ».

Dans la boite de dialogue, cliquer sur le bouton du paramètre groovyFiles pour désigner le fichier de la macro à installer (on peut sélectionner plusieurs fichiers de macros à la fois).

Puis cliquer sur le bouton .

La macro est analysée pour déterminer dans quelle catégorie elle va être installée (repérage de la ligne commençant par ‘package…’).

De nouvelles macros sont disponibles régulièrement, depuis plusieurs sources, voir la section 8.1.

9.1.3 Modifier une macro

Dans la vue « Macro », clic-droit sur l’icone de la macro puis lancer la commande « Éditer » du menu contextuel. La modification du script requière des connaissances en programmation en langage Groovy (voir section suivante).

Une macro peut être associée à plusieurs scripts Groovy secondaires qui ne sont pas visibles dans la vue Macro. Pour les éditer, il faut utiliser la vue Fichier ouverte sur le dossier contenant la macro et les scripts, faisant partie de la hiérarchie du dossier $TXMHOME/scripts/macro ou bien cocher le bouton « all » de la vue Macro pour pouvoir les sélectionner.

9.1.4 Créer une macro

9.1.4.1 À l’aide du bouton « Nouvelle macro »

La façon la plus simple de créer une macro est de cliquer dans TXM sur le bouton « Nouvelle macro » dans la vue Macro. Cette commande demande d’abord de saisir le nom de la macro puis ouvre un éditeur de texte pour éditer le squelette de script générique proposé :

ce script générique commence par des modèles de lignes de déclaration de différents types de paramètres utilisables pour une macro (chemin de fichier, chaîne de caractères, chemin de dossier… voir la section suivante pour la liste de tous les types de paramètres disponibles). Chaque ligne de déclaration commence par le préfixe « \@Field \@Option ». Il faut décommenter une ligne d’exemple de déclaration pour l’utiliser (supprimer les deux caractères // en début de ligne).
On obtient par exemple :
\@Field \@Option(name="inputFile", usage="fichier XML d’entrée", widget="FileOpen", required=true, def='')
def inputFile
Glose : déclaration du paramètre obligatoire « inputFile » de type « FileOpen » (soit « chemin de fichier à ouvrir ») avec la valeur par défaut vide.
Détail :
« \@Field » commence la déclaration
« \@Option(...) » contient la déclaration
« name="inputFile" » définit le nom du paramètre comme « inputFile »
« usage="fichier XML d’entrée" » définit la documentation du paramètre, affichée quand on survole le paramètre dans la fenêtre de saisie des paramètres au lancement de la macro
« widget="FileOpen" » déclare le type du paramètre et l’aspect visuel qu’il prendra dans la fenêtre de saisie des paramètres (voir la section 9.1.4.3 « Types de paramètres disponibles pour une macro »)
« required=true » déclare le paramètre comme obligatoirement à renseigner
« def='' » déclare la valeur par défaut du paramètre, vide dans ce cas
« def inputFile » déclare la variable Groovy correspondant au paramètre
vient ensuite la ligne Groovy provoquant l’ouverture de la boite de dialogue de saisie des paramètres. Exemple :
if (!ParametersDialog.open(this)) return
Glose : ouvrir la boite de dialogue de saisie des paramètres puis, exécuter la suite de la macro si on appuie sur le bouton « Exécution » ou abandonner l’exécution de la macro si on appuie sur le bouton « Annuler ».
Remarque : si cette ligne est commentée ou omise la macro ne demandera pas de saisie de valeurs de paramètres.
viennent ensuite des exemples de lignes de manipulation de différents objets sélectionnés dans l’interface utilisateur (éléments de la vue Corpus : corpus, sous-corpus, partition, résultat ainsi que d’autres vues, éditeurs de texte ouverts, etc.). Exemple :
println "Corpora selection: "+corpusViewSelection
Glose : Affiche dans la console le nom de l’élément sélectionné dans la vue Corpus.

9.1.4.2 Par copie de fichier

Une autre façon d’ajouter une macro, depuis l’extérieur de TXM, est de déposer un script Groovy ayant un nom se terminant par « …Macro.groovy » dans le dossier $TXMHOME/scripts/macro/org/txm/macro ou dans un de ses sous-dossiers, puis de rafraîchir la vue « Macro » pour y voir apparaître son nom.

9.1.4.3 Types de paramètres disponibles pour une macro

Les paramètres d’une macro peuvent être de types suivants (valeurs possibles du paramètre « widget » de la déclaration d’une macro) :

Integer : nombre entier (comme un seuil en fréquence)
Float : nombre réel (comme un seuil d’indice)
Boolean : booléen oui/non (pour les options de traitement)
String : chaîne de caractères (comme un nom de sous-corpus)
StringArray : chaîne à choisir parmi une liste prédéfinie (un paramètre supplémentaire « metaVar » doit lister les chaines possibles séparées par une tabulation)
StringArrayMultiple : chaînes à choisir parmi une liste prédéfinie (un paramètre supplémentaire « metaVar » doit lister les chaines possibles séparées par une tabulation)
Text : chaîne de caractères longue, sur plusieurs lignes (comme un commentaire)
Password : chaîne de caractères qui ne sera pas affichée dans l’interface (pour saisir des mots de passe)
FileOpen ou File : pour désigner un fichier à ouvrir en lecture (pour la lecture d’un fichier TSV par exemple)
FileSave : pour désigner un fichier à créer (pour la sauvegarde d’un résultat par exemple)
Folder : pour désigner un dossier (un dossier où sauver un résultat par exemple)
Date : date au format « mois/jour/année »
Query : requête CQL
Separator : pour afficher un séparateur entre paramètres (pour indiquer des regroupements logiques par exemple). Renseigner la valeur par défaut (ref) pour préfixer la ligne séparatrice par un label.

9.1.4.4 Variables prédéfinies

Les macros peuvent accéder à divers objets de TXM par le biais de variables prédéfinies :

Nom de la variable	Description	Type Groovy
corpusViewSelection	l’élément couramment sélectionné dans la vue Corpus (corpus, sous-corpus, partition, résultat)	Object
corpusViewSelections	liste d’éléments couramment sélectionnés dans la vue Corpus	List<Object>
selection	l’élément couramment sélectionné (sélection de texte dans un éditeur, icône de requête dans la vue Requête…)	Object
selections	une liste d’éléments couramment sélectionnés	List<Object>
monitor	objet interne permettant d’accéder à l’interface utilisateur pendant l’exécution de la macro	org.txm.rcpapplication.utils.JobHandler
gse	objet interne permettant l’appel mutuel entre scripts Groovy et donc entre macros	org.txm.rcpapplication.utils.GSERunner qui étend la classe groovy.util.GroovyScriptEngine
editor	fenêtre de résultats ou éditeur de texte couramment sélectionné	org.eclipse.ui.IWorkbenchPart

9.1.4.5 Appel d’une macro depuis une autre macro

Il est possible d’appeler une macro depuis une autre macro en utilisant une référence au moteur de scripts enregistrée dans la variable « gse » (pour Groovy Script Engine).

Par exemple, pour appeler une macro « B » à partir d’une macro « A », on peut utiliser la ligne de code suivante dans la macro « A » :

gse.runMacro(BMacro, ["param1":value1, "param2":value2])

Remarques :

le nom complet du script de la macro B est « BMacro.groovy », d’où la désignation par le nom « BMacro » (la macro est affichée sous le nom «B » dans la vue Macro)
« param1 » et « param2 » sont des paramètres de la macro « B ».

Si des paramètres obligatoires de la macro appelée, B dans l’exemple, ne sont pas renseignés lors de l’appel, la macro ouvrira sa boite de dialogue de saisie des paramètres pour saisir leur valeur.

9.2 Bibliothèque d’utilitaires (macros prédéfinies)

TXM est livré avec plusieurs macros utilitaires prédéfinies, accessibles depuis la vue Macro. Ces macros sont organisées par dossiers thématiques :

txt : traitement des fichiers au format texte brut (TXT)
texte : traitement des fichiers aux format traitement de texte (MS DOCX, ODT, RTF, etc.)
xml : traitement des fichiers au format XML
xsl : pour l’utilitaire donnant accès aux traitements XSL
csv : traitement des fichiers au format CSV
html : traitement des fichiers au format HTML
pdf : traitement des fichiers au format PDF
table : traitement de tableaux MS Excel
transcription : traitement de transcriptions d’enregistrements
commands : utilitaires réalisant des commandes TXM avancées
r : appels de scripts R
stats : utilitaires offrant divers services statistiques
export : utilitaires d’export de résultats
imports : utilitaires de préparation d’import de corpus
cqp : utilitaires mobilisant des requêtes CQL
edition : utilitaires de manipulation d’éditions de texte
tiger : exploitation d’annotations syntaxiques
annotation : traitement des annotations CQP
urs : traitement des annotations URS
conversion : utilitaires de conversion de formats de fichiers
corpus : utilitaires de manipulation de corpus
debug : utilitaires aidant au diagnostic (fournissant divers numéros de version des composants de TXM)
files : utilitaires de manipulation de fichiers
projects : utilitaires développés dans le cadre de projets de recherche
misc : autres utilitaires
utils : utilitaires pour macros

9.2.1 Aide à la préparation des fichiers sources d’un corpus

9.2.1.1 format TXT

Macros d’aide à la manipulation de fichiers au format texte brut (.txt).

9.2.1.1.1 ChangeEncoding

Traitement par lot de conversion d’encodage de caractères pour tous les fichiers d’un dossier.

Paramètres

inputDirectory : le dossier contenant les fichiers à ré-encoder. Attention : les fichiers sont modifiés sur place
inputEncoding : encodage actuel des caractères des fichiers. Si l’encodage n’est pas connu la valeur ”??” permet de lancer le devin d’encodage automatiquement fichier par fichier (marche pas à tous les coups)
outputEncoding : encodage des caractères souhaité des fichiers.

9.2.1.1.2 CharList

Dénombre tous les caractères d’un fichier Unicode UTF-8.

Paramètres

inputFile : le fichier à analyser.

9.2.1.1.3 SearchInDirectory

Affiche toutes les lignes des fichiers texte d’un dossier contenant une expression régulière donnée.

Cette macro sert au réglage d’expressions régulières pour le traitement de sources.

Paramètres

inputDirectory : dossier des fichiers à chercher
regexp : l’expression régulière à chercher
characterEncoding : l’encodage des caractères utilisé par les fichiers (par défaut : UTF-8)

Remarque : FindMultiLineRegExp est une version permettant de chercher des expressions sur plusieurs lignes.

9.2.1.1.4 SearchReplaceInDirectory

Chercher/Remplacer par lot tous les fichiers d’un dossier.

Paramètres

inputDirectory : le dossier contenant les fichiers à traiter. Attention : les fichiers sont modifiés sur place
extension : l’extension des fichiers à traiter (par exemple ‘\.txt’, ‘\.xml’ ou ‘\.*’ pour tous les fichiers[63]
find : l’expression régulière[64] à rechercher (Voir également la faq et le manuel pour la syntaxe des expressions régulières). L’usage préalable de la macro SearchInDirectory peut être utile pour procéder au réglage de cette expression de recherche (car elle ne fait que lister ce qui est trouvé, sans faire de remplacement).
replaceWith : la chaîne de remplacement (qui peut contenir des groupes mémorisés de l’expression recherchée : $1, $2, etc.)
encoding : l’encodage des caractères des fichiers à traiter (par exemple UTF-8, windows-1253, x-MacRoman, etc.)

Remarque : MultiLineSearchReplaceInDirectory est une version permettant de chercher et remplacer des expressions sur plusieurs lignes.

9.2.1.1.5 SplitFileRegExp

Éclate un fichier TXT en plusieurs fichiers en s’appuyant sur une expression régulière de ligne de séparation entre les textes. Les noms de fichiers créés peuvent s’appuyer sur des éléments de contenu des lignes de séparation.

Paramètres

inputFile : fichier TXT d’entrée
fileEncoding : encodage des caractères du fichier d’entrée et des fichiers de sortie (‘UTF-8’ recommandé, mais peut être ‘cp1252’ sous Windows ou ‘MacRoman’ sous Mac)
outputDir : le dossier des fichiers de sortie
separatorLineRegex : expression régulière de la ligne de séparation entre les textes
includeSeparatorLine (optionnel) : inclure le contenu de la ligne de séparation au début de chaque sous fichier de texte
outputFilenamePrefix (optionnel) : préfixe des noms de fichiers de sortie
outputFilePattern (optionnel) : patron des noms de fichiers de sortie. Quand ce paramètre n’est pas utilisé, les noms de fichiers sont numérotés de 1 à N.
outputFileExtension (optionnel) : extension des noms de fichiers de sortie

Exemple d’application 1 : numérotation automatique des fichiers de sortie

Soit le fichier fichierTest contenant trois textes séparés par une ligne de la forme a=… type=… :

a=1 type=a
blah blah blah
a=2 type=a
blih blih blih
blih blih blih
a=3 type=b
bloh bloh bloh

en appelant la macro avec les paramètres suivants :

inputFile : chemin vers fichierTest
fileEncoding : UTF-8
outputDir : chemin vers dossier de sortie
separatorLineRegex : a=(.*) type=(.*)
includeSeparatorLine (optionnel) : décoché (non)
outputFilenamePrefix (optionnel) : texte-
outputFilePattern (optionnel) : <vide>
outputFileExtension (optionnel) : .txt

on obtient trois fichiers :

texte-1.txt contenant
blah blah blah
texte-2.txt contenant
blih blih blih blih blih blih
texte-3.txt contenant
bloh bloh bloh

Exemple d’application 2 : récupération d’éléments des lignes séparatrices pour nommer les fichiers de sortie

Soit le même fichierTest, en appelant la macro avec les paramètres suivants :

inputFile : chemin vers fichierTest
fileEncoding : UTF-8
outputDir : chemin vers dossier de sortie
separatorLineRegex : a=(.*) type=(.*)
includeSeparatorLine (optionnel) : décoché (non)
outputFilenamePrefix (optionnel) : texte-
outputFilePattern (optionnel) : $1-$2
outputFileExtension (optionnel) : .txt

on obtient trois fichiers :

texte-1-a.txt contenant
blah blah blah
texte-2-a.txt contenant
blih blih blih blih blih blih
texte-3-b.txt contenant
bloh bloh bloh

Exemple d’application 3 : inclusion de la ligne séparatrice au début de chaque fichier de sortie

Soit le même fichierTest, en appelant la macro avec les paramètres suivants :

inputFile : chemin vers fichierTest
fileEncoding : UTF-8
outputDir : chemin vers dossier de sortie
separatorLineRegex : a=(.*) type=(.*)
includeSeparatorLine (optionnel) : coché (oui)
outputFilenamePrefix (optionnel) : texte-
outputFilePattern (optionnel) : $1-$2
outputFileExtension (optionnel) : .txt

on obtient trois fichiers :

texte-1-a.txt contenant
a=1 type=a blah blah blah
texte-2-a.txt contenant
a=2 type=a blih blih blih blih blih blih
texte-3-b.txt contenant
a=3 type=b bloh bloh bloh

Exemple d’application 4 : éclatement d’un corpus au format IraMuTeQ (Alceste)

Pour éclater un fichier source au format IRaMuTeQ (ou Alceste) encodé avec deux mots étoilés, on peut utiliser les paramètres suivants[65] :

separatorLineRegex : ^\\\*\\\*\\\*\\\*\\\*([^\_\\n]+)\_([^\*\\n]+) \\\*([^\_\\n]+)\_([^\*\\n]+)
outputFilePattern (optionnel) : $1-$2-$3-$4

9.2.1.2 Formats de traitements de textes

Macros d’aide à la manipulation de fichiers au format traitement de texte (.docx, .doc, .odt, .rtf…).

9.2.1.2.1 Text2TXT

Traitement par lot de conversion de format de tous les fichiers textes d’un dossier (.doc, .docx, .odt, .rtf, .html…) vers le format texte brut TXT. La transformation vers TXT est assurée par LibreOffice ou OpenOffice.

Paramètres

inputDirectory : le dossier qui contient les fichiers à traiter.
Attention : les fichiers résultats TXT seront enregistrés dans ce même dossier
extension : extensions des fichiers à traiter

Prérequis

TXM version 0.7.5 et inférieure → LibreOffice ou OpenOffice 3.x
TXM version 0.7.6 et supérieure → LibreOffice ou OpenOffice toutes versions

Remarque : les fichiers TXT résultants peuvent être importés dans TXM en les déposant dans un nouveau dossier et en indiquant ce dossier comme source du module d’import TXT+CSV.

9.2.1.3 Tableaux & formats de tableurs

Macros d’aide à la manipulation de corpus formatés en tableau (.xlsx. .ods, .csv, .tsv…).

9.2.1.3.1 Excel2XML, ExcelDir2XML

9.2.1.3.1.1 Introduction

Macros de transformation d’un fichier Excel .xlsx, dont certains champs contiennent du texte, en un fichier XML importable dans TXM avec le module d’import XTZ+CSV pour une analyse textométrique :

chaque ligne correspondra à un texte dans le corpus TXM
l’édition de ce texte sera constituée d’une seule page
certaines colonnes sont converties en métadonnées de textes
certaines colonnes sont converties en sections de textes

Ces macros sont une évolution de la macro CSV2XML. Outre la possibilité de travailler directement sur un fichier excel ou sur un dossier, elles apportent aussi l’affichage des métadonnées dans l’édition, au début de chaque texte. Lorsqu’il y a une métadonnée de date[66] notée JJ/MM/AAAA, elles peuvent analyser cette date et générer automatiquement des métadonnées supplémentaires codant séparément le mois, l’année, le jour de la semaine.

Deux macros sont disponibles :

Excel2XML qui convertit un seul fichier Excel à la fois
ExcelDir2XML qui convertit d’un coup tous les fichiers Excel d’un dossier, en appellant successivement la macro Excel2XML sur chaque fichier (elle possède les mêmes paramètres que la macro précédente)

Le fichier XML résultat des macros transcode le tableau d’entrée de la façon suivante :

il associe une unité de structure de base, ou unité textuelle (voir textTag plus bas), à chaque ligne du tableau d’entrée (par exemple, les réponses d’un même répondant ou panéliste dans une enquête, ou les caractéristiques d’un objet, etc. De façon générale n’importe quel tableau dont certaines colonnes contiennent du texte)
il associe à chacune de ces unités textuelles des propriétés, ou métadonnées, issues du contenu d’autres colonnes “catégorisants” la ligne correspondante dans le tableau d’origine (ces colonnes qualifient le répondant ou correspondent à des réponses à des questions fermées par exemple)
il ajoute à chacune de ces unités textuelles des sous unités de structures encodant le contenu d’autres colonnes à contenu “textuel” de la ligne d’origine (ces colonnes correspondent à des réponses à des questions ouvertes par exemple)

L’idée est de pouvoir comparer dans TXM les unités textuelles entre elles, soit les répondants par exemple, en s’appuyant sur leurs propriétés (issues de certaines colonnes de la ligne, ou caractéristiques du répondant par exemple) et sur les mots qu’ils utilisent dans leurs réponses (issues de certaines colonnes de la ligne, ou réponses textuelles à chaque question “textuelle” non fermée par exemple).

9.2.1.3.1.2 Paramètres

Entrée
- chemin soit du fichier de départ, soit du dossier de départ selon la macro appelée :
  - pour la macro Excel2XML :
    - inputFile : chemin du fichier .xlsx[68] en entrée
      Remarques
    - La première ligne contient les noms de colonnes
    - Le nom du fichier résultat est construit à partir de celui du fichier d’entrée en remplaçant l’extension par ‘.xml’
  - pour la macro ExcelDir2XML :
    - inputDirectory : chemin du dossier de fichiers .xlsx
- sheetName : nom de la feuille à utiliser dans le fichier Excel (si aucun nom est fourni, la première feuille du fichier est utilisée)
- metadataColumnList : liste des noms de colonnes encodant les propriétés des unités textuelles à construire - colonnes catégorisant le répondant, séparés par une virgule : (par exemple : ‘identifiant,age,sexe’).
  Les noms de ces colonnes seront utilisés pour nommer les propriétés correspondantes après normalisation automatique (réduction en minuscules, sans caractères spéciaux ni accents)
- dateColumnList : liste des noms de colonnes encodant des dates à décoder de la forme ‘jj/mm/aaaa’ (exemple ‘01/02/2018’ pour le 1er février 2018)
- textColumnList : liste des noms de colonnes encodant le contenu textuel - colonnes contenant les réponses aux questions ouvertes du répondant, séparés par une virgule : (par exemple : ‘reponse1,reponse2’)
  Les noms de ces colonnes seront utilisés après normalisation automatique pour nommer les balises qui délimiteront ces contenus textuels
Sortie
- rootTag : nom de la balise XML racine du document résultat (par exemple : ‘enquete’)
- textTag : nom de la balise XML encodant les unités textuelles correspondant à chaque ligne du tableau d’entrée (par exemple : ‘reponse’)

9.2.1.3.1.3 Exemple de tableau .xlsx de départ

enquête.xlsx[69] :

identifiant	date de la réponse	âge	sexe	réponse à Q1	réponse à Q2
id1	01/02/2018	23	F	Réponse à la première question par le premier répondant.	Réponse à la deuxième question par le premier répondant.
id2	02/02/2018	24	H	Réponse à la première question par le deuxième répondant.	Réponse à la deuxième question par le deuxième répondant.
id3	01/02/2018	25	H	Réponse à la première question par le troisième répondant.	Réponse à la deuxième question par le troisième répondant.

9.2.1.3.1.4 Exemple de fichier .xml résultat de la conversion du tableau .xlsx

enquête.xml :

<?xml version="1.0" encoding="UTF-8"?>
<enquete>
  <pb n="1"/>
  <reponse identifiant="id1" datedelareponse="01/02/2018"
datedelareponsejour="01" datedelareponsejoursemaine="jeudi"
datedelareponsemois="02" datedelareponseannee="2018" age="23" sexe="F">
    <metadata>
      <list type="unordered">
        <item>identifiant : id1 </item>
        <item>date de la réponse : 01/02/2018 </item>
        <item>âge : 23</item>
        <item>sexe : F </item>
      </list>
    </metadata>
    <reponseaq1>
      <p>
        <head>
          <hi>réponse à Q1 : </hi>
        </head>
        Réponse à la première question par le premier répondant.
      </p>
    </reponseaq1>
    <reponseaq2>
      <p>
        <head>
          <hi>réponse à Q2 : </hi>
        </head>
        Réponse à la deuxième question par le premier répondant.
      </p>
    </reponseaq2>
  </reponse>
  <pb n="2"/>
  <reponse identifiant="id2" datedelareponse="02/02/2018"
datedelareponsejour="02" datedelareponsejoursemaine="vendredi"
datedelareponsemois="02" datedelareponseannee="2018" age="24" sexe="H">
    <metadata>
      <list type="unordered">
        <item>identifiant : id2 </item>
        <item>date de la réponse : 02/02/2018 </item>
        <item>âge : 24</item>
        <item>sexe : H </item>
      </list>
    </metadata>
    <reponseaq1>
      <p>
        <head>
          <hi>réponse à Q1 : </hi>
        </head>
        Réponse à la première question par le deuxième répondant.
      </p>
    </reponseaq1>
    <reponseaq2>
      <p>
        <head>
          <hi>réponse à Q2 : </hi>
        </head>
        Réponse à la deuxième question par le deuxième répondant.
      </p>
    </reponseaq2>
  </reponse>
  <pb n="3"/>
  <reponse identifiant="id3" datedelareponse="01/02/2018"
datedelareponsejour="01" datedelareponsejoursemaine="jeudi"
datedelareponsemois="02" datedelareponseannee="2018" age="25" sexe="H">
    <metadata>
      <list type="unordered">
        <item>identifiant : id3 </item>
        <item>date de la réponse : 01/02/2018 </item>
        <item>âge : 25</item>
        <item>sexe : H </item>
      </list>
    </metadata>
    <reponseaq1>
      <p>
        <head>
          <hi>réponse à Q1 : </hi>
        </head>
        Réponse à la première question par le troisième répondant.
      </p>
    </reponseaq1>
    <reponseaq2>
      <p>
        <head>
          <hi>réponse à Q2 : </hi>
        </head>Réponse à la deuxième question par le troisième répondant.
      </p>
    </reponseaq2>
  </reponse>
</enquete>

Obtenu avec les paramètres de conversion suivants :

rootTag : enquete
textTag : reponse
metadataColumnList : identifiant,date de la réponse,âge,sexe
dateColumnList : date de la réponse
textColumnList : réponse à Q1,réponse à Q2

Remarque : on voit que le paramètre choisi pour ‘dateColumnList’ a provoqué l’extraction des différents éléments composant la date en créant plusieurs propriétés :

datedelareponse=“01/02/2018” : la date complète
datedelareponsejour=“01” : le jour dans le mois
datedelareponsejoursemaine=“jeudi” : le jour dans la semaine
datedelareponsemois=“02” : le mois
datedelareponseannee=“2018” : l’année

9.2.1.3.1.5 Import du fichier .xml dans TXM

copier le ou les fichiers .xml résultats dans un dossier source
lancer l’import XTZ+CSV (commande ‘Fichier / Importer / XTZ+CSV’)
- désigner le dossier source
- il est recommandé les paramètres d’import suivants :
  - Éditions > Nombre de mots par page = 100000
    Un grand nombre de mots par page permet d’obtenir tout le contenu d’une ligne du tableau d’origine dans une seule page d’édition du texte construit
  - Plans textuels > Hors texte à éditer = metadata

Remarque : chaque unité textuelle correspondant à une ligne du tableau source commence par la liste de ses propriétés (ou métadonnées), et cette liste est encadrée par une structure ”<metadata>”. Placer la structure ”<metadata>” dans le champ “Hors texte à éditer” permet de ne pas mettre les mots de cette liste dans les mots de l’unité textuelle, tout en les affichant dans l’édition de l’unité textuelle.

9.2.1.3.1.6 Exploitation dans TXM

Avec le corpus construit on peut, par exemple, comparer des catégories de répondants entre elles en réalisant un calcul de spécificité du vocabulaire sur une partition. Par exemple sur une partition des valeurs de la propriété ‘sexe’ des structures ‘reponse’.

9.2.1.3.1.6.1 Exemple d’édition

Première page de l’édition du texte correspondant au tableau enquête.xlsx (correspond à la première ligne du tableau).

9.2.1.4 Fichiers & dossiers

Macros d’aide à la manipulation de fichiers et de dossiers.

9.2.1.4.1 RenameFiles

Renomme tous les fichiers d’un dossier ayant une certaine extension par chercher/remplacer dans leur nom. Cette macro repose sur l’utilisation du chercher/remplacer d’expression régulière de caractères avec reprise.

Paramètres

inputDirectory : dossier des fichiers à renommer ;
extension : expression régulière de filtrage des fichiers par extension (suffixe du nom de fichier commençant par un point ‘.’) ;
find : expression régulière décomposant les noms de fichiers d’origine. On utilise des groupes de parenthèses ‘(…)’ pour mémoriser des parties d’origine du nom ;
replaceWith : expression de remplacement pour le nouveau nom. Les parties d’origine mémorisées peuvent être insérées dans le nouveau nom en fonction de la position de leur groupe de parenthèses dans l’expression de recherche ‘find’ : la première partie - mémorisée dans le premier groupe de parenthèses - est insérée avec la chaine ‘$1’, la deuxième partie - mémorisée dans le deuxième groupe de parenthèses - est insérée avec la chaine ‘$2’, et ainsi de suite jusqu’à épuisement des groupes de parenthèses mémorisés.

Exemple 1 : pour renommer des fichiers nommés ‘document 1.txt’, ‘document 2.txt’, ‘document 3.txt’ en ‘texte001.txt’, ‘texte002.txt’, ‘texte003.txt’ on utilise les paramètres suivants :

find : .* ([0-9])\.txt
- glose : un nom de fichier composé d’une séquence de n’importe quels caractères, suivie d’une espace, puis d’un chiffre (mémorisé par les parenthèses), puis d’une extension ‘.txt’
replaceWith : texte00$1.txt
- glose : la chaine ‘texte00’, concaténée au chiffre mémorisé (par le premier, et unique, groupe de parenthèses de l’expression ‘find’), puis à l’extension ‘.txt’

Exemple 2 : pour changer l’extension de fichiers ‘.tt’ en ‘.txt’ on utilise les paramètres suivants :

find : (.*)\.tt
- glose : un nom de fichier composé d’une séquence de n’importe quels caractères (mémorisée par le groupe de parenthèses) suivie d’une extension ‘.tt’
replaceWith : $1.txt
- glose : concaténer le nom d’origine, sans l’extension, avec la nouvelle extension ‘.txt’

9.2.1.5 Format XML

Macros d’aide à la manipulation de fichiers au format XML (.xml).

9.2.1.5.1 TXT2XML

Transforme tous les fichiers TXT d’un dossier en fichiers XML. Les fichiers XML sont déposés dans un sous-dossier résultat ‘out’.

La macro transforme : - l’encodage initial des caractères - la présence initiale de caractères ‘&’ - la présence initiale de caractères ‘<’ - l’extension des fichiers résultats

Elle n’ajoute aucun encodage XML supplémentaire.

Paramètres

inputDirectory : dossier des fichiers à transformer
characterEncoding : système d’encodage des caractères des fichiers texte (par défaut : Unicode UTF-8)
rootTag : nom de la balise XML racine des fichiers XML produits (par exemple : ‘text’)

Remarque : le dossier résultat peut être importé dans TXM en l’indiquant comme dossier source du module d’import XML/w+CSV ou XTZ+CSV.

9.2.1.5.2 Taltac2XML

Transforme un fichier au format Taltac en un fichier au format XML pour être importé par le module XTZ+CSV : - chaque ligne de délimitation de texte avec ses propriétés est encodée par une balise ‘<doc …>’ encodant les propriétés dans des attributs.

  - par exemple, la ligne :
    
    \*\*\*\*yahoobanque1 \*data=31gen \*autore=da \*rubrica=da
    \*ora=08 \*agenzia=reuters \*grafici=da
    
    devient :
    
    \<doc ident="yahoobanque1" data="31gen" autore="da" rubrica="da"
    ora="08" agenzia="reuters" grafici="da"\>

chaque ligne de délimitation de section interne à un texte est encodée par une structure ayant le nom du délimiteur.
- par exemple, les lignes :
  
  ++++titolo
  
  Charges et dépréciations entraînent une perte pour Deutsche Bank
  
  ++++testo
  
  Deutsche Bank a fait état jeudi d’une perte avant impôts de 2,6 milliards d’euros pour le quatrième trimestre, sous le coup d’importantes charges de restructuration.
  
  …
  
  deviennent :
  
  <titolo>
  
  Charges et dépréciations entraînent une perte pour Deutsche Bank
  
  </titolo>
  
  <testo>
  
  Deutsche Bank a fait état jeudi d’une perte avant impôts de 2,6 milliards d’euros pour le quatrième trimestre, sous le coup d’importantes charges de restructuration.
  
  …
  
  </testo>

La macro transforme par ailleurs : - l’encodage initial des caractères vers UTF-8 - la présence initiale de caractères ‘&’ - la présence initiale de caractères ‘<’

Le nom du fichier résultat est créé à partir du nom du fichier d’entrée en ajoutant le suffixe ‘.xml’.

Paramètres - inputFile : le chemin vers le fichier d’entrée au format Taltac - characterEncoding (optionnel) : système d’encodage des caractères du fichier d’entrée

  - par exemple : *windows-1252* sous Windows, *UTF-8* sous Linux,
   etc.

  - voir la liste des systèmes d'encodage disponibles pour bien
   utiliser des désignations connues
   \<https://groupes.renater.fr/wiki/txm-users/public/character\_encodings\_list\>

titleTag (optionnel) : nom de la balise Taltac de délimitation de section encodant les titres (de préfixe ‘++++’)
- cette option formatera le contenu de cette section sous forme de titre dans l’édition du corpus
- par exemple : titolo
addParagraphs (optionnel) : chaque ligne de texte du fichier d’entrée est encodée dans un paragraphe XML (<p> … </p>), pour aérer la page d’édition.

Import dans TXM : - il est recommandé d’importer le fichier XML résultant avec le module d’import XTZ+CSV :

  - dans le système de fichiers :
    
      - créer un dossier MONCORPUS
    
      - copier le fichier résultat .xml dans le dossier
       MONCORPUS

  - dans TXM :
    
      - lancer l'import XTZ : 'Fichier \> Importer\> XML-XTZ+CSV'
    
      - dans le formulaire de paramètres d'import :
        
          - indiquer le chemin vers le dossier MONCORPUS
        
          - dans la rubrique “Éditions” mettre le paramètre
           'Nombre de mots par page' à une grande valeur, par
           exemple *50000*, pour que chaque (petit) texte puisse
           avoir sa propre page
        
          - dans la rubrique “Commandes”, indiquer *doc* comme
           structure délimitant les contextes de concordance
           (ainsi, un contexte de concordance ne pourra pas se
           prolonger sur le texte suivant ou précédent) ;
        
          - dans la rubrique “Plans textuels” mettre dans le
           paramètre 'Hors texte à éditer' la valeur *list*,
           pour que les métadonnées de textes situées en début
           d'édition de chaque texte, juste après le titre s'il
           y en a un, ne soient pas indexées.

9.2.1.5.3 XMLStatistics

Calcul de la table des fréquences de toutes les balises et attributs XML utilisées dans les fichiers d’un dossier (utile pour une vue d’ensemble quantitative de l’usage des balises dans des documents dont on ne connait pas les principes d’encodage).

Paramètres - inputDirectory : le dossier qui contient les fichiers XML à analyser - tsvFile : le fichier TSV où les résultats seront sauvegardés - usePaths : dénombre tous les chemins d’éléments présents (exemple : /TEI/text/body/div/post/p, etc.) - useAttributes : inclut les différents noms d’attributs présents dans le dénombrement - useAttributeValues : inclut les différentes valeurs d’attributs utilisées dans le dénombrement

9.2.1.5.4 Validate

Vérification de la syntaxe des fichiers (.xml) d’un dossier.

Paramètres - inputDirectory : le dossier qui contient les fichiers XML à vérifier - edit : option pour ouvrir chaque fichier ayant une erreur de syntaxe dans un éditeur XML de TXM[71], en positionnant le curseur à l’endroit indiqué par l’erreur - maxEditors : nombre maximum de fichiers en erreur à ouvrir simultanément - debug : afficher les commentaires techniques supplémentaires pour la mise au point

9.2.1.5.5 Format

Formatage des fichiers (.xml) d’un dossier pour en faciliter la lecture.

Paramètres - inputDirectory : le dossier qui contient les fichiers XML à formater - outputDirectory : le dossier qui contiendra les fichiers formatés - omitXmlDeclaration : ne pas ajouter la déclaration XML au début du fichier (eg ‘<?xml version=“1.0”?>’) - indent : indenter les balises hiérarchiquement - suppressIndentation : liste d’éléments (balises), séparés par des espaces, dont il ne faut pas indenter le contenu[72] - doubleSpace : liste d’éléments (balises), séparés par des espaces, qui seront précédés d’un saut de ligne supplémentaire - encoding : encodage des caractères du résultat (utf-8 si vide) - namespacesDeclaration : liste de déclarations d’espaces de noms - namespaces -, séparées par des espaces, qui seront insérées dans le XML résultat - debug : afficher les commentaires techniques supplémentaires pour la mise au point

9.2.1.5.6 NumberElement

Traitement par lot de numérotation d’un élément XML de tous les fichiers XML d’un dossier.

Paramètres - inputDirectory : le dossier qui contient les fichiers à traiter - outputDirectory : le dossier qui contiendra le résultat - elementName : le nom de l’élément à numéroter (exemple : pb) - elementAttribute : le nom de l’attribut encodant la numérotation (exemple : n) - countStart : valeur initiale de la numérotation (exemple : 1) - valuePrefix : préfixe optionel acollé à la numérotation (exemple : ‘https://gallica.bnf.fr/iiif/ark:/12148/bpt6k35936/f’) - valueSuffix : suffixe optionel acollé à la numérotation (exemple : ‘/full/full/0/native.jpg’) - debug (true|false) : afficher les messages d’erreur

Fonctionnement

Cette macro peut s’utiliser de deux façons, - a) ajouter simplement un numéro à des éléments, comme des numéros de page :

  - elementName = pb

  - elementAttribute = n

  - countStart = 1  
   ce qui produira par exemple la numérotation suivante :
    
    ...
    
    \<pb n="1"/\>
    
    ...
    
    \<pb n="2"/\>
    
    ...
    
    \<pb n="3"/\>
    
    ...
    
    etc.

1. ajouter des valeurs incluant une numérotation, comme des adresses d’accès à des images de fac-similiés en ligne :
- elementName = pb
- elementAttribute = facs
- countStart = 102
- valuePrefix = https://gallica.bnf.fr/iiif/ark:/12148/bpt6k35936/f
- valueSuffix = /full/full/0/native.jpg
  ce qui produira par exemple le résultat suivant :
  
  …
  
  <pb facs=“https://gallica.bnf.fr/iiif/ark:/12148/bpt6k35936/f102/full/full/0/native.jpg"/\>
  
  …
  
  <pb facs=“https://gallica.bnf.fr/iiif/ark:/12148/bpt6k35936/f103/full/full/0/native.jpg"/\>
  
  …
  
  <pb facs=“https://gallica.bnf.fr/iiif/ark:/12148/bpt6k35936/f104/full/full/0/native.jpg"/\>
  
  …
  
  etc.

Note : cette macro s’appuie sur XSLT en générant une feuille XSL à la volée. On peut s’en inspirer en modifiant la XSL générée pour réaliser différents traitements XSL depuis une macro.

9.2.1.5.7 CombineNumberElement

Exemple de macro appelant une autre macro deux fois avec des paramètres différents.

Paramètres

Aucun.

Fonctionnement

Appelle la macro NumberElement pour une numérotation de pages, puis pour la désignation d’images de fac-similé en ligne.

9.2.1.5.8 ForceWordIDs

Pour les fichiers source XML encodant déjà les mots avec des éléments “w” ou “pc”, force la valeur de leur attribut “id” à une valeur compatible avec le calcul du retour au texte de TXM.

Les valeurs d’attributs “id” pré-existantes sont sauvegardées dans l’attribut “foreign-id”.

Paramètres - inputFile: le fichier XML d’entrée - outputFile: le fichier résultat

Usage

À appliquer aux fichiers sources avant l’import dans TXM.

9.2.1.5.9 ExecXSL

Traitement par lot d’application d’une feuille de transformation XSLT sur tous les fichiers XML d’un dossier.

Paramètres - XSLFile : la feuille XSL à appliquer - inputDirectory : le dossier qui contient les fichiers à traiter - outputDirectory : le dossier qui contiendra le résultat

9.2.1.5.10 TeiHeader2MetadataCSV

Récupère des informations dans les entêtes TEI de fichiers source pour construire un tableau de métadonnées “metadata.csv”.

Paramètres - inputDirectory : dossier des fichiers source à analyser - propertiesFile : fichier de paramètres associant des noms de métadonnées à des requêtes XPath d’extraction des informations correspondantes au sein des fichiers source - CSVoutputFile : fichier de sortie “metadata.csv” - columnSeparator : caractère séparateur de colonnes pour le format CSV - columnSeparator : caractère séparateur de champs pour le format CSV

Remarque : n’importe quel format XML peut être utilisé pour réaliser des extractions. Les requêtes XPath n’ont pas à être liées à la TEI et ne sont pas limitées à des sous-élements de teiHeader.

9.2.1.5.10.1 Exemple

Exemple de fichier de paramètres “propertiesFile”, le fichier “est-republicain.properties” pour le corpus “Est républicain”[73] :

date-edition-en-clair=/tei:TEI/tei:teiHeader/tei:fileDesc/tei:titleStmt/tei:title/tei:date/text()

date-edition-formatée=/tei:TEI/tei:teiHeader/tei:fileDesc/tei:titleStmt/tei:title/tei:date/@when

Glose : - la première requête extrait le contenu d’un élément date, pour créer la métadonnée date-edition-en-clair (dateeditionenclair dans TXM une fois normalisée par l’import) - la deuxième requête extrait la valeur de l’attribut @when d’un élément date, pour créer la métadonnée date-edition-formatée (dateeditionformatee dans TXM une fois normalisée par l’import)

Le fichier “metadata.csv” résultant pour l’année 1999 (dossier de sources “Annee1999”) a la forme suivante :

id,date-edition-en-clair,date-edition-formatée

1999-06-09,“9 juin 1999”,“1999-06-09”

1999-07-04,“4 juillet 1999”,“1999-07-04”

1999-07-10,“10 juillet 1999”,“1999-07-10”

1999-07-29,“29 juillet 1999”,“1999-07-29”

1999-08-07,“7 août 1999”,“1999-08-07”

1999-05-29,“29 mai 1999”,“1999-05-29”

1999-07-07,“7 juillet 1999”,“1999-07-07”

1999-09-19,“19 septembre 1999”,“1999-09-19”

…

9.2.1.6 Transcriptions d’enregistrements

Macros d’aide à la manipulation de fichiers de transcription d’enregistrement (.docx, .doc, .odt, .txt, .trs).

9.2.1.6.1 TextTranscription2TRS

Assistance à l’encodage et à la transformation de transcriptions en format texte (.doc, .odt, .rtf du logiciel Transana) vers le format XML du logiciel Transcriber pour l’import dans TXM avec le module d’import Transcriber+CSV.

Utilisation

Voir le « Tutoriel d’import de transcriptions d’enregistrements dans TXM » à <https://groupes.renater.fr/wiki/txm-users/public/tutoriel\_import\_transcriptions\>.

Paramètres - odtDir : le dossier qui contient les fichier documents (ODT, Word, RTF) à traiter - debug : pour afficher plus de messages dans la console si la macro échoue

9.2.1.7 Portails de Presse

Macros d’aide à la manipulation de fichiers exportés depuis des sources de données variées.

9.2.1.7.1 EuroPresse2XML

Assistance à la récupération et à la transformation des exports HTML du portail EuroPresse pour l’import dans TXM avec le module d’import XML/w+CSV.

Utilisation

Voir le « Tutoriel d’importation de corpus d’articles exportés du portail EUROPRESS dans TXM » à <https://groupes.renater.fr/wiki/txm-users/public/tutoriel\_europresse\>.

Paramètres - rootDir : le dossier qui contient le dossier “orig” (qui lui même contient les fichiers HTML) - encoding: l’encodage des fichiers HTML. Sous Windows : iso-8859-1, Linux : UTF-8 - debug : afficher plus de message en cas d’erreur

9.2.1.8 Formats spécialisés

Macros d’aide à la manipulation de fichiers aux formats divers.

9.2.1.8.1 TXM2CoNLL2009

Exporte un corpus au format CoNLL2009[74].

Utilisation

Sélectionner le corpus à exporter dans la vue corpus, puis lancer la macro.

Paramètres - outputFile : fichier TSV contenant le résultat de l’export - encoding : encodage de sortie du fichier TSV, par défau “UTF-8” - sentenceProperty : propriété de structure représentant une phrase - posProperty : propriété de mot codant la morphosyntaxe du mot - lemmaProperty : propriété de mot codant le lemme du mot

9.2.1.8.2 PennTreebank2TIGER

Conversion par lot ou par fichier du format Penn Treebank au format TIGER-XML.

Paramètres - SourceFile: drives one file conversion process mode - SourceFolder: drives several files in a folder conversion process mode
→ fill only the field to be used - TargetFile: if SourceFile then use that target file - XMLTargetID: if SourceFile then use that target ID - TargetFolder: : if SourceFolder then use that target folder to save targets

  - target files are named from the source filename with the
   extension stripped and '.xml' added

  - target ID are named from the source filename with the
   extension stripped

MaximumNumberOfSentences: maximum number of sentences to convert per file (set to ‘0’ to convert all sentences)

9.2.2 Variantes de commandes TXM

9.2.2.0.1 NIndex

9.2.2.0.1.1 Installation de la macro

télécharger la macro NindexMacro.groovy à <https://sharedocs.huma-num.fr/wl/?id=4CZvtLzpoR7HwamY6hxAxyLyJhPORZzT\>
copier le fichier dans <dossier utilisateur>/TXM/scripts/macro/org/txm/macro/commands
télécharger la macro CQPUtilsMacro.groovy à <https://sharedocs.huma-num.fr/wl/?id=6VlcKQmXJ6Ng0MFn7MT7NGEE0SFw0hGY\>
copier le fichier dans <dossier utilisateur>/TXM/scripts/macro/org/txm/macro/cqp
dans TXM 0.7.9 ou inférieur, installer les bibliothèques Java complémentaires suivantes :
1. télécharger l’archive office.zip à <https://sharedocs.huma-num.fr/wl/?id=fFpoqmVX3qoEyyNQ1NuLSignUAUiUgQs\>
2. copier dans <dossier utilisateur>/TXM/scripts/lib les 7 fichiers qu’elle contient :
  - commons-validator-1.4.0.jar
  - java-rdfa-0.4.2.jar
  - jena-core-2.7.4.jar
  - jena-iri-0.9.4.jar
  - odfdom-java-0.8.10-incubating.jar
  - org.apache.xerces_2.9.0.v201101211617.jar
  - simple-odf-0.8.1-incubating.jar
3. quitter puis relancer TXM
ouvrir ou rafraîchir la vue Macro
accéder au dossier ‘commands’
double-cliquer sur l’icone de la macro NIndex pour la lancer

9.2.2.0.1.2 Fonctionnement de la macro

La macro NIndex assiste le décompte de séquences de mots dans des corpus ou des sous-corpus. Elle généralise la commande Index de TXM 0.7.8 à N requêtes CQL. Les séquences sont fournies dans un fichier d’entrée (paramètre inputFile), au format général d’une séquence par ligne. Trois formats de séquences sont proposés : - séquences de formes de mots (ou de forme de lemme ou de forme de pos, etc.) comme par exemple des séquences déjà repérées par TXM ou par un autre logiciel, exemple :

Cathédrale Notre-Dame

rue de la Chanvrerie

...

séquences d’expressions régulières sur les formes de mots, exemple :

Tour.*

rue|avenue|boulevard de la [A-Z].*
requêtes CQL, exemple :

“Cathédrale”%cd “Notre-Dame”%cd

“rue|avenue|boulevard”%c “de”%c “la”%c [word=“[A-Z].*”]

…

Dans les séquences de formes de mots et d’expressions régulières sur les formes de mots, les formes et les expressions régulières sont séparées par un caractère espace (pour chercher une forme contenant un espace il faut utiliser une expression régulière exprimant ce caractère Unicode).

9.2.2.0.1.3 Types de séquences

Le type de séquences interprété par NIndex est déterminé par le paramètre inputIsCQL. Si ce paramètre est sélectionné (vrai), les séquences sont interprétées comme des requêtes CQL ; sinon elles sont interprétées soit comme des formes soit comme des expressions régulières de formes en fonction du contenu de chaque ligne.

Le paramètre inputWordProperty permet de choisir la propriété de mot qui sera utilisée pour les recherches de séquences de formes ou de séquences d’expression régulière de forme. Par exemple : - avec la valeur ‘word’ (par défaut) ce seront les séquences de forme graphiques qui seront recherchées - avec la valeur ‘frlemma’ ce seront les séquences de formes de lemmes qui seront recherchées - avec la valeur ‘frpos’ ce seront les séquences d’étiquettes morphosyntaxiques qui seront recherchées - etc. en fonction de l’étiquetage des mots du corpus

9.2.2.0.1.4 Propriété de mot dénombrée

Le paramètre outputWordProperty permet de choisir quelle propriété de mot sera utilisée pour réaliser le dénombrement des séquences trouvées. Par exemple : - avec la valeur ‘frlemma’ ce seront les séquences de formes de lemmes qui seront dénombrées - avec la valeur ‘word’ (par défaut) ce seront les séquences de formes graphiques qui seront dénombrées - avec la valeur ‘frpos’ ce seront les séquences d’étiquettes morphosyntaxiques qui seront dénombrées - etc. en fonction de l’étiquetage des mots du corpus

9.2.2.0.1.5 Regroupement des décomptes par séquence

Quand les séquences sont des requêtes CQL ou des expressions régulières, il est possible de regrouper les décomptes de leurs réalisations en sélectionnant le paramètre groupByQuery. Dans ce cas il y a une fréquence par séquence dans le tableau de sortie.

9.2.2.0.1.6 Liste des corpus à interroger

Les corpus dans lesquels chercher sont soit sélectionnés dans la vue Corpus (avant de lancer la macro), soit fournis sous la forme d’une liste de noms de corpus à l’appel de la macro par une autre macro.

9.2.2.0.1.7 Format de sortie

La macro NIndex écrit son résultat dans un fichier de sortie (paramètre outputFile), deux formats sont proposés : - ODS : format tableur Calc de Libre Office (extension .ods) - TSV : format texte tabulé TSV (caractère tabulation pour séparer les colonnes)

Quand le paramètre odsOutputFormat est sélectionné la sortie se fait au format ODS, sinon TSV.

9.2.2.0.1.7.1 Sortie au format ODS

La sortie au format tableur est composée de deux feuilles : - feuille principale (Sheet1) : contient le tableau des décomptes avec les colonnes suivantes :

  - **corpus** : nom du corpus, au format chaine

  - **word query** ou **CQL** : la requête de séquence, au format
   chaine

  - **word values** : les réalisations de la séquence, au format
   chaine (cette colonne n'est pas présente si le paramètre
   groupByQuery est sélectionné)

  - **f** : la fréquence des réalisations ou de la requête si
   groupByQuery est sélectionné, au format nombre entier

feuille de renseignement des résultats (properties), contient le tableau des paramètres du calcul avec les informations suivantes :
- date : date de lancement de la macro
- time : heure de lancement de la macro
- machine : nom de la machine utilisée
- user : identifiant de l’utilisateur ayant lancé le calcul
- macro : nom de la macro
- valeurs des paramètres : corpora, inputFile, inputIsCQL, inputWordProperty, outputFile, odsOutputFormat, outputWordProperty, groupByQuery

9.2.3 Appels répétitifs de commandes TXM

9.2.3.0.1 AdvancedPartition

Crée une partition à partir de requêtes CQL, comme l’onglet ‘Avancé’ de la boite de dialogue de création de partition, mais en gagnant les avantages suivants : - comme les requêtes CQL font partie intégrante de la macro, il suffit de la relancer pour re-créer la même partition sans avoir à re-saisir la liste complète des requêtes à chaque fois. - par ailleurs, ‘Copier’ la macro permet de créer facilement des variantes d’une partition. - pour les requêtes de parties complexes, on a un meilleur contrôle sur leur saisie et sur leur réglage. - un test est effectué qui s’assure que la somme des tailles des parties créées est égale à la taille du corpus (ou sous-corpus) partitionné : cela ne garantit pas que la partition soit mathématiquement valide (sans reste et sans recouvrements), mais cela peut dans beaucoup de cas aider à détecter des anomalies (le test valide une condition nécessaire mais non suffisante). - au final (une fois que la partition est satisfaisante), on dispose - avec le fichier du code de la macro- d’une archive, une trace, permettant de se rappeler précisément comment la partition a été construite. - la macro est un programme que l’on peut souplement enrichir et personnaliser, et donc en particulier la construction des requêtes peut elle-même s’appuyer sur des calculs annexes : comme la récupération de listes de valeurs de propriétés des structures d’un corpus ou d’informations externes, de listes de requêtes stockées dans des fichiers, etc.

Paramètres - un corpus ou un sous-corpus sélectionné dans la vue Corpus

Utilisation - éditer la macro en lançant “Menu contextuel[75] > Éditer”

  - définir le nom de la partition (à partir de la ligne 27),
   exemple 'decennies' :
    
    def NAME = "decennies"

  - définir les noms des parties, exemple '60s', '70s', etc. :
    
    def PARTNAMES = [
    
    "60s",
    
    "70s",
    
    "80s",
    
    "90s",
    
    "2000s",
    
    "2010s",
    
    ]

  - définir les requêtes, exemple :
    
    def QUERIES = [
    
    '[\_.text\_annee="(1959|196.)"] expand to text',
    
    '[\_.text\_annee="197."] expand to text',
    
    '[\_.text\_annee="198."] expand to text',
    
    '[\_.text\_annee="199."] expand to text',
    
    '[\_.text\_annee="200."] expand to text',
    
    '[\_.text\_annee="201."] expand to text',
    
    ]

  - sauver la macro avec le bouton 'disquette' de la barre
   d'outils ou le menu “Fichier \> Sauvegarder”

sélectionner un corpus ou un sous-corpus dans la vue Corpus
lancer la macro
- la macro vérifie que la somme des tailles des parties est bien égale au (sous-)corpus sur lequel est définie la partition
  - si les tailles sont égales la nouvelle partition apparaît dans la vue Corpus
  - sinon la console indique les deux tailles et la partition n’est pas créée

9.2.3.0.2 CrossedPartitionBuilder

Construit une partition en croisant les différentes valeurs de plusieurs propriétés d’une même structure.

Utilisation

Sélectionner le corpus pour lequel produire la partition puis lancer la macro.

Paramètres - structuralUnit : nom de la structure à utiliser. Par exemple pour faire une partition sur les textes il faut saisir “text” ; - structuralUnitPropertiesList : liste des propriétés de la structure à combiner, séparer les noms par des virgules. Par exemple pour le corpus “DISCOURS” et la structure “text”, on peut saisir “loc,type” ; - debug : afficher les requêtes utilisées par TXM pour produire chaque partie sans créer la partition.

9.2.4 Moteur CQP

9.2.4.0.1 CreateCQPList

Permet de définir une liste de mots (ou plus généralement de valeurs de propriétés) utilisable dans les requêtes CQL.

Utilisation

Voir le « Tutoriel d’utilisation des listes CQL » à <https://groupes.renater.fr/wiki/txm-users/public/tutoriel\_d\_utilisation\_des\_listes\_cql\>.

Paramètres

A éditer directement dans le fichier script.

9.2.4.0.2 ExecCQP

Permet de faire exécuter une ligne de commande au moteur CQP.

Utilisation

Les instructions d’utilisation se trouvent en commentaire au début du fichier script avec un rappel des commandes CQP utiles.

Paramètres - statement : une requête CQP. Attention à bien finir la requête par ”;”

9.2.4.0.3 SetMatchingStrategy

Permet de changer la stratégie de résolution des opérateurs ?, *, + sur les occurrences du langage de requêtes CQL au cours d’une session de travail. Par exemple, pour la requête[76] :

[enpos=“DET”]? [enpos=“ADJ”]* [enpos=“NN”] ([enpos=“PREP”] [enpos=“DET”]? [enpos=“ADJ”]* [enpos=“NN”])*

Avec le texte suivant à interroger :

the old book on the table in the room - pour la stratégie ‘shortest’ le résultat est le suivant (3 matches)

r1= book

r2= table

r3= room - pour la stratégie ‘longest’[77] le résultat est le suivant (1 match)

r1= the old book on the table in the room - pour la stratégie ‘standard’[78] le résultat est le suivant (3 matches)

r1= the old book

r2= the table

r3= the room - pour la stratégie ‘traditional’ le résultat est le suivant (7 matches recouvrants)

r1= the old book

r2= old book

r3= book

r4= the table

r5= table

r6= the room

r7= room

La stratégie de résolution par défault est ‘standard’.

9.2.4.0.3.1 Paramètres

matchingStrategy : valeur à choisir parmi : shortest, standard, longest, traditional.

9.2.5 Scripts R

9.2.5.0.1 ExecR

Dessine l’histogramme des fréquences d’un index dans un SVG et l’affiche dans une fenêtre de TXM.

Utilisation

Il faut sélectionner un index (de corpus ou de partition) dans la vue Corpus avant de lancer la macro. Il n’y a pas de filtrage d’affichage, il faut donc filtrer l’index en amont de la macro. L’ordre des barres est celui des lignes de résultat de l’index.

Paramètres

Aucun

9.2.5.0.2 PlotSpecif

Appel la fonction “specificities.distribution.plot” du package textometry[79] pour afficher la courbe de densité du modèle statistique des spécificités.

Utilisation

Pour plus de détail sur la fonction “specificities.distribution.plot”, voir la documentation du package[80].

Paramètres - f : fréquence de la forme dans la partie - F : fréquence totale de la forme dans le corpus - t : nombre d’occurrences de la partie - T : nombre total d’occurrences du corpus

9.2.6 Statistiques complémentaires

9.2.6.0.1 BasicVocabulary

Ce traitement implémente le concept textométrique de “forme(s) de base” et “vocabulaire de base” (on parle quelquefois aussi de “forme banale” et de “banalité”), cf. par ex. Lafon 1980 p. 152, ou Lebart & Salem 1994 p. 176 - les références bibliographiques complètes sont dans la rubrique Documents de référence du site Textométrie. Une forme (un mot) de base est un mot qui n’est spécifique dans aucune partie. En pratique, la macro BasicVocabulary exporte dans un fichier tous les mots de base automatiquement repérés dans un tableau de spécificités, en fonction d’un indice (ou score) de spécificité maximum. Le tableau produit reprend les colonnes du tableau initial de spécificités en insérant en plus, après la colonne F (fréquence totale du mot), une colonne “score_max”, donnant le maximum des indices de spécificité (en valeur absolue) sur la ligne (sorte d’amplitude maximale de la spécificité du mot sur l’ensemble de parties considéré).

Utilisation

Il faut sélectionner un tableau de spécificités dans la vue Corpus avant de lancer la macro. Pour le choix du scoreMax : - la communauté textométrique considère qu’un mot est spécifique d’une partie lorsque son indice de spécificité est d’au moins 3 (ou d’au moins 2 pour une approche moins restrictive), donc le scoreMax sera habituellement choisi avec une valeur inférieure à 3, généralement 2 ou moins. - on peut indiquer une valeur décimale, la partie décimale étant séparée de la partie entière par un point (notation à la manière anglosaxone), ex. 1.5. - plus le scoreMax est petit, plus il est sélectif, en revanche moins il permet de considérer les mots de haute fréquence, pour lesquels statistiquement les scores de spécificité “montent” beaucoup plus facilement. Il peut donc être intéressant de choisir un score pas trop restrictif, puis de dépouiller les résultats dans le tableur en les triant par F décroissant ou/et score_max croissant.

Paramètres - outputDirectory : dossier dans lequel sera placé le fichier résultat créé. Le bouton à droite avec trois petits points permet de naviguer dans l’arborescence des dossiers de la machine (son utilisation est recommandée pour s’assurer d’avoir la bonne syntaxe d’écriture du chemin localisant le dossier). - outputFile : nom du fichier résultat à créer. Ce fichier sera de type .tsv, exploitable dans les tableurs (comme Calc ou Excel) avec comme séparateur de colonne la tabulation. - scoreMax : le seuil appliqué aux scores de spécificité, exprimé comme un nombre entier ou décimal positif. Une ligne du tableau est sélectionnée pour être exportée dans le tableau résultat de la macro si et seulement si tous les scores de spécificité observés sur cette ligne sont inférieurs (en valeur absolue) au scoreMax. Habituellement, le scoreMax n’excède pas 3, voire 2.

9.2.6.0.2 Specif2Coin

[voir également la macro Specif2Throw plus récente et plus générale]

Affiche la probabilité a priori (avant de faire les lancés) d’obtenir N faces ‘pile’ consécutives en lançant une pièce au pile ou face, en regard avec la spécificité équivalente. On considère qu’une pièce a 50% de chances (1 chance sur 2) de tomber sur la face ‘pile’ à chaque lancé - la pièce n’est pas biaisée et les lancés sont indépendants.

Utilisation

Lancer la macro directement par double-clic.

Paramètres

La macro prend un seul paramètre et trois options : - nthrows : le nombre de lancés ‘pile’ consécutifs

La macro affiche - selon les options : - displayProba : toutes les probabilités de 1 à nthrows lancés en détaillant :

  - n : le nombre de 'pile' consécutifs

  - p : la probabilité correspondante

  - % : le pourcentage correspondant

  - pe : la probabilité exprimée en notation avec exposant en base
   10

  - s : la spécificité équivalente (l'exposant de la probabilité,
   soit son logarithme en base 10)

onlyMainRanks : s’utilise avec l’option displayProba pour n’afficher que les probabilités des rangs décimaux principaux (1, 2…, 10, 20…, 100, 200…)

displayCoins : plutôt que le détail de la probabilité, liste pour une spécificité S- donnée, le nombre équivalent de lancés ‘pile’ consécutifs correspondants exprimé sous la forme d’un intervalle : nombre de lancés minimum - nombre de lancés maximum. Par exemple ‘-10 = 30-33’ signifie : une spécificité S- de ‘-10’ équivaut à entre 30 et 33 lancés ‘pile’ consécutifs.

Les limites du calcul sont celles de la machine. Une machine 64-bit peut typiquement calculer la probabilité de 1023 lancés consécutifs.

9.2.7 Cartographie

9.2.7.0.1 FranceMercatorIGNMap

Cette macro ouvre une carte de France interactive dans TXM, centrée sur une adresse donnée. Elle utilise les services web du Géoportail de l’IGN.

9.2.7.0.1.1 Installation de la macro

télécharger la macro FranceMercatorIGNMapMacro.groovy à <https://sharedocs.huma-num.fr/wl/?id=f6cG1DEVFfjg1tZZaCAfHA9u4SjnCERo\>
copier le fichier dans <dossier utilisateur>/TXM/scripts/macro/org/txm/macro/map
télécharger l’archive de librairies Javascript leaflet.zip à <https://sharedocs.huma-num.fr/wl/?id=s9od4X8I1VtakigdmYe9Q3oO882IPMto\>
extraire l’archive dans <dossier utilisateur>/TXM/results, ceci doit créer le dossier ‘leaflet’ dans le dossier ‘results’ (là où sera générée la page HTML de chaque carte produite)

9.2.7.0.1.2 Fonctionnement de la macro

Vous devez être connecté à Internet pour que la macro puisse fonctionner :

ouvrir la vue Macro
accéder au dossier ‘map’
double-cliquer sur l’icone de la macro FranceMercatorIGNMap pour la lancer

La macro prend deux paramètres : - une adresse située en France, de type :

rue de la Goutte-d'Or, Paris

ou

Lyon

une clé d’accès IGN : la clé s’obtient sur le site de l’IGN <http://professionnels.ign.fr\>

Quand elle est lancée : - elle ouvre une carte de France sur le lieu de l’adresse demandée. Le lieu est calculé par le service Photon[81] qui s’appuie lui-même sur OpenStreetMap[82]

  - le lieu est indiqué par un marqueur libellé avec l'adresse du
   lieu

  - la zone approximative du lieu est entourée d'un rectangle bleu
   (un clic sur la carte fait disparaitre la zone)

le fond de carte est composé de cartes IGN
le zoom par molette ou bouton ‘+’ et ‘-’ change le type de cartes
on dispose en haut à droite d’un sélecteur de couches
- ce sélecteur permet de masquer ou de faire afficher différentes couches
- pour chaque couche il permet de choisir son niveau de transparence
- il permet de choisir la place de chaque couche dans l’empilement en déplaçant le nom de la couche dans le menu
on peut chercher une nouvelle adresse avec le bouton chercher (ayant une icone de loupe) situé en haut à gauche
le bouton de position situé en bas à gauche permet de faire afficher les coordonnées de la souris dans la carte
le bouton ‘plein écran’ situé en bas à droite permet de faire utiliser tout l’écran à la carte (cela ne fonctionne complètement que quand on fait ouvrir le fichier HTML de la carte dans un navigateur externe. Dans TXM la fenêtre de la carte ne dépasse pas les autres fenêtres)
l’échelle courante est affichée en bas à gauche

Remarque : les services web du Géoportail de l’IGN proposent deux ensembles de couches : en projection Mercator et en projection Lambert93. Cette macro propose un jeu de couches pris dans l’ensemble Mercator. On peut choisir d’autres couches en changeant le code de la macro. Votre clé d’accès détermine si vous pouvez accéder à telle ou telle couche.

Remarque2 : la récupération des informations depuis les serveurs de l’IGN peut être assez lente, en dizaines de secondes.

9.2.8 Multimodalité & Multimédia

9.2.8.0.1 refaireTRS

Cette macro met à jour l’édition d’une transcription importée avec le module d’import XML Transcriber+CSV pour pouvoir jouer le son de chaque énoncé depuis l’édition en cliquant dessus.

9.2.8.0.1.1 Installation de la macro

télécharger la macro refaireTRSMacro.groovy à <https://sharedocs.huma-num.fr/wl/?id=Ht3ckTRjuJwiiO51outo7L2Q2Nnj1L3c\>
copier le fichier dans <dossier utilisateur>/TXM/scripts/macro/org/txm/macro/edition
télécharger la feuille XSL refaireEditionTRS.xsl à <https://sharedocs.huma-num.fr/wl/?id=ndGP9YmgAEkEnDjb9soVt1YLOPwmHrTw\>
copier le fichier dans <dossier utilisateur>/TXM/xsl

9.2.8.0.1.2 Fonctionnement de la macro

La macro prend deux paramètres : - un corpus sélectionné dans la vue Corpus qui contient les transcriptions dont il faut changer l’édition (le corpus doit être sélectionné avant l’appel de la macro) - le chemin du dossier contenant les fichiers d’enregistrements son ou vidéo (le chemin est demandé dans la boite de dialogue de saisie des paramètres de la macro lors de son appel)

Lancement :

ouvrir la vue Macro
accéder au dossier ‘edition’
double-cliquer sur l’icone de la macro refaireTRS pour la lancer

9.2.8.0.1.3 Fonctionnement des éditions après l’exécution de la macro

ouvrir une édition de transcription, directement ou par retour au texte depuis une concordance
cliquer sur les mots d’un énoncé pour commencer la lecture au début de l’énoncé
re-cliquer sur des mots de l’édition pour stopper la lecture

9.2.9 Annotation externe de corpus

9.2.9.1 BuildWordPropTable, InjectWordPropTable

Macros d’assistance à la correction ou à l’ajout de propriétés de mots.

[Remarque : l’usage de ces macros est essentiellement remplacé par l’outil d’annotation/correction de propriétés de mots par concordance depuis TXM 0.8.0]

Utilisation

Voir le « Tutoriel de correction ou d’ajout de propriétés de mots » à <https://groupes.renater.fr/wiki/txm-users/public/tutoriel\_correction\_mots\>.

Lancement de macros

9.2.9.2 ApplyParameters

À chaque appel, les macros sauvegardent leurs valeurs de paramètres dans un fichier annexe nommé <nom de macro>Macro.properties, situé à côté du fichier de script de la macro. Le contenu de ce fichier est utilisé pour pré-charger le formulaire de paramètres avec ces valeurs lors de l’appel suivant de la macro. Ceci correspond à un mécanisme de mémorisation des valeurs de paramètres entre appels d’une même macro.

La macro ApplyParameters permet de désigner un fichier de valeurs de paramètres <nom de macro>Macro.properties pour faire utiliser les valeurs de paramètres qu’il contient par une macro désignée par son fichier de script.

Cela permet d’organiser plusieurs jeux de valeurs de paramètres pour une macro donnée, stockés dans des fichiers .properties indépendants. On peut alors appeler la macro avec différents jeux de valeurs à la demande. Pour créer un jeu de valeurs, il suffit de copier le fichier <nom de macro>Macro.properties initial créé par TXM au départ, et d’éditer son contenu avec un éditeur de texte, en respectant la syntaxe des fichiers .properties : - chaque ligne correspond à un paramètre - elle a la forme ‘nom du paramètre’ = ‘valeur du paramètre’ (sans espaces autour du ‘=’ ni apostrophes ’‘) - les lignes commençant par’#’ sont des lignes de commentaires (elles sont ignorées)

Exemple de fichier .properties de la macro GetXPath :

#Mon Feb 25 11:16:45 CET 2019

lineNumber=true

debug=false

wrapLines=true

filterByFileExtension=true

XPath=//tei\:title/text()

srcFile=/home/sheiden/Documents/tmp/test/01elements.xml

fileExtension=.xml

srcDirectory=/home/sheiden/Corpus/src/Hobbes/eeboOK

Paramètres - propertiesFile : chemin vers le fichier de valeurs de paramètres à utiliser.
Exemple : /home/sheiden/TXM/scripts/macro/org/txm/macro/xml/GetXPathMacro.properties - macroFile : chemin vers le fichier de script de la macro à lancer.
Exemple : home/sheiden/TXM/scripts/macro/org/txm/macro/xml/GetXPathMacro.groovy

9.3 Partager vos macros avec la communauté des utilisateurs de TXM

Vous pouvez éditer la page <https://groupes.renater.fr/wiki/txm-users/public/macros> du wiki des utilisateurs de TXM pour documenter et mettre un lien vers vos macros.

9.4 Piloter par scripts Groovy

Les scripts servent à piloter la plateforme TXM pour : - appeler n’importe quelle commande TXM : lancer une recherche à partir d’une requête CQL, appliquer un modèle statistique, exporter et sauvegarder des résultats dans un fichier, etc. - utiliser des paramètres personnalisés pour chacune de ces commandes ; - enregistrer et lancer une séquence de commandes pour des recherches usuelles.

Leur usage permet à l'utilisateur d'étendre les fonctionnalités de
la plateforme à l'aide de scripts[83].

Les macros sont des scripts spécialisés offrant des services de saisie et de mémorisation de paramètres.

Les scripts et macros sont écrits en langage Groovy (König, 2007) (http://groovy.codehaus.org).

Vous trouverez une courte introduction à l’utilisation de ce langage à l’adresse : http://onjava.com/pub/a/onjava/2004/09/29/groovy.html

Trois livres de référence pourront vous donner plus d’informations : - Groovy in action(König, Glover, King, Laforge, & al., 2007)

Groovy programming: an introduction for Java developers(Barclay & Savage, 2007)
Programming Groovy(Venkat, 2008)

Le texte des scripts à exécuter peut se trouver dans un fichier ou être simplement sélectionné dans une fenêtre (voir la section « Éditeur de texte »).

La meilleure manière de commencer à écrire vos propres script Groovy est de copier un des scripts exemples inclus dans la plateforme, dossier « C:\Documents and Settings\<identifiant de l’utilisateur>\TXM\scripts\groovy\samples »[84][85]. Par exemple, le script « conc.groovy »[86] calcule automatiquement une concordance du mot « je » dans le corpus DISCOURS puis exporte les résultats au format CSV dans un fichier nommé « conc.txt ».

Pour que vous puissiez exécuter vos propres scripts Groovy depuis TXM, ces derniers doivent se trouver dans le dossier « C:\Documents and Settings\<identifiant de l’utilisateur>\TXM\scripts\user ». La hiérarchie des packages Groovy commence à partir de ce dossier.

Pour créer un script, déplacer un script dans ce dossier ou aller dans la vue « Fichier » (voir la section 3.2.1.1.2 La vue « Fichier » et « l’éditeur de texte »), clic-droit sur le dossier « user », puis sélectionner « créer un fichier », donner un nom. Par exemple « test.groovy ». Pour modifier le script, il faut double-cliquer sur son icone.

9.4.1 Exécuter un script

On peut exécuter un script Groovy par sept moyens différents :

depuis un éditeur de texte[87]:
menu contextuel « Groovy > Exécuter la sélection de texte » exécute le texte sélectionné dans l’éditeur ;
menu contextuel « Groovy > Exécuter le Script » exécute le script se trouvant dans l’éditeur ;
menu contextuel « Groovy > Exécuter un fichier Groovy » exécute un script se trouvant dans un fichier ;
raccourcis clavier « F11 » exécute le texte sélectionné dans l’éditeur ;
raccourcis clavier « Ctrl-F11 » exécute le script se trouvant dans l’éditeur ;
depuis la vue Fichier :
menu contextuel sur l’icone d’un fichier « Exécuter le Script » exécute le script contenu dans le fichier ;
raccourcis clavier « F12 » exécute le dernier script exécuté.

9.4.2 Utilisation de librairies tierces (fichiers .jar ou .so)

Pour qu’une librairie tierce (fichier « .jar »[88] ou « .so »[89]) soit accessible depuis un script Groovy, il suffit de la déposer dans le dossier « $HOME\TXM\scripts\lib ». Après avoir relancé TXM, les packages et fonctions correspondants sont importables depuis les scripts Groovy.

9.4.3 Comment utiliser les objets de TXM depuis Groovy

Groovy étant basé sur le langage Java (Arnold, Gosling, & Holmes, 2005) (Gosling, Joy, Steele, Bracha, & Buckley, 2014)[90], il donne accès à tous les modules Java de TXM.

La façon d’appeler les commandes de TXM depuis Java et donc depuis Groovy est documentée dans la Javadoc de TXM située à l’adresse : http://txm.sourceforge.net/javadoc.

Par exemple, les paramètres de la commande Concordance sont décrits dans le package « org.txm.rcpapplication.editors.concordances », documenté à l’adresse <http://txm.sourceforge.net/javadoc/TXM/RCP/org/txm/rcpapplication/editors/concordances/ConcordancesEditor.html>.

Toutes les commande décrites dans cette documentation peuvent être exécutées dans un script Groovy.

9.4.4 Scripts Groovy de démarrage et d’arrêt de TXM (prestart, start, prestop et stop)

TXM peut exécuter automatiquement quatre scripts à des moments clés lors du démarrage et de l’arrêt de TXM :

au lancement de TXM, avant l’initialisation du noyau
- si un script nommé “prestart.groovy” est présent dans le répertoire $TXMHOME/scripts/groovy/user il est exécuté
- ce moment permet de réaliser des tests et réglages globaux à TXM (eg recherche de mises à jour particulières, réglage de préférences comme le choix du mode de résolution du moteur CQP, etc.)
au lancement de TXM, après l’initialisation du noyau (démarrage des moteurs CQP et R, et chargement des corpus et de leurs résultats)
- si un script nommé “start.groovy” est présent dans le répertoire $TXMHOME/scripts/groovy/user il est exécuté
- ce moment permet de réaliser des réglages ou précalculs en fonction des corpus présents
au moment d’arrêter TXM, avant l’arrêt du noyau
- si un script nommé “prestop.groovy” est présent dans le répertoire $TXMHOME/scripts/groovy/user il est exécuté
- ce moment permet de réaliser des opérations de cloture en fonction des corpus présents (eg sauvegarde de certains résultats ou annotations)
au moment d’arrêter TXM, après l’arrêt du noyau
- si un script nommé “stop.groovy” est présent dans le répertoire $TXMHOME/scripts/groovy/user il est exécuté
- ce moment permet de réaliser des opérations de cloture globales à TXM

9.5 Piloter par scripts R

TXM permet de faire exécuter un script R au moteur statistique R (R Core Team, 2014) intégré.

9.5.1 Exécuter un script R

Un script R peut être exécuté par cinq moyens différents :

depuis un éditeur de texte[91]:
menu contextuel « R > Exécuter le Script » exécute le script se trouvant dans l’éditeur ;
menu contextuel « R > Exécuter la sélection comme script R » exécute le texte sélectionné dans l’éditeur ;
raccourcis clavier « F11 » exécute le texte sélectionné dans l’éditeur ;
raccourcis clavier « Ctrl-F11 » exécute le script se trouvant dans l’éditeur ;
depuis la vue Fichier :
menu contextuel sur l’icone d’un fichier « R > Exécuter le Script » exécute le script contenu dans le fichier.

Session exemple

Exécution du script de démonstration « HelloWorld.R » :

accéder au dossier des scripts R d’exemple livrés avec TXM à partir de la vue Fichier : ouvrir le dossier $TXMHOME/scripts/samples/R
ouvrir le script « HelloWorld.R » dans un éditeur en double-cliquant sur son icone
ouvrir la “Console R” pour pouvoir lire les sorties du script : ouvrir “Affichage > Vues > ‘Console R’” à partir du menu principal
dans le menu contextuel de l’éditeur contenant le script “HelloWorld.R”, lancer “R > Exécuter le Script”

9.5.2 Utilisation des résultats et objets TXM depuis R

Tous les résultats de calculs TXM dont l’icone est affichée dans la vue Corpus peuvent être transférés dans R sous la forme d’une structure de données : pour cela utiliser la commande « Envoyer vers R » du menu contextuel du corpus ou de l’icone de résultat depuis la vue Corpus.

La console affiche alors le nom de l’objet R créé pour vous permettre de l’utiliser dans des scripts R. Un petit « R » en exposant à gauche de couleur rouge est ajouté à l’icone de l’objet TXM pour confirmer le transfert dans R. Certains transferts sont réalisés automatiquement par TXM pour certains calculs (tables lexicales, graphique de progression, spécificités…).

La vue « Variables R » affiche la liste des données déjà transférées dans R. Pour ouvrir la vue « Variables R », ouvrir le menu « Affichage > Vues > Variables R ». Vous pouvez copier dans le presse-papier le nom de la donnée transférée avec l’entrée « Copier » du menu contextuel de son icone ou en pressant Contrôle-C au clavier quand l’icone est sélectionnée. Vous pouvez alors coller le nom du symbole dans un script R.

9.5.3 Utiliser la perspective R pour organiser son accès à R

La perspective R vous permet de configurer rapidement l’interface de TXM avec les vues utiles au travail avec R :

un bouton « Nouvelle session » de création de script de session R est ajouté à la barre d’outils : pour ouvrir un éditeur de texte sur un fichier de script nommé « sessionX.R » créé automatiquement dans le dossier « $USER_HOME/TXM/scripts/R ».
un onglet « Variables R » est ajouté dans le panneau de gauche, donnant un accès rapide à la vue « Variables R »;
la partie droite de l’interface empile trois fenêtres :
la zone d’édition des scripts R ;
la console R ;
la console TXM.

Le basculement dans la perspective « Corpus », pour reprendre votre session d’analyse de corpus, fermera la vue « Variables R » et la console R.

Vous pouvez basculer d’une perspective à l’autre à n’importe quel moment.

Par défaut, l’interface de TXM est configurée selon la perspective « Corpus ». Pour changer de perspective, vous pouvez utiliser la barre d’outils des perspectives située en haut à gauche de l’interface, sous la barre d’outils principale, contenant les boutons « R » et « Corpus ». Vous pouvez également utiliser le menu principal (en haut à gauche) « Affichage / Perspectives / R ou Corpus ».

9.5.4 L’environnement R de TXM

Au démarrage, TXM effectue quelques réglages du moteur statistiques R (Rserve) :

L’encodage des caractères par défaut est initialisé à Unicode UTF-8
Le chemin du workspace R est initialisé à :
Sous Windows :
« C:\Utilisateurs\<identifiant de l’utilisateur>\TXM\R »
ou bien
« C:\Documents and Settings\<identifiant de l’utilisateur>\TXM\R »
Sous Mac OS X :
« /Users/<identifiant de l’utilisateur>/TXM/R »
Sous Linux :
« /home/<identifiant de l’utilisateur>/TXM/R ».
Le dossier d’installation des packages R est initialisé à :
Sous Windows :
« C:\Utilisateurs\<identifiant de l’utilisateur>\TXM\R\libraries »
ou bien
« C:\Documents and Settings\<identifiant de l’utilisateur>\TXM\R\libraries »
Sous Mac OS X :
« /Users/<identifiant de l’utilisateur>/TXM/R\libraries »
Sous Linux :
« /home/<identifiant de l’utilisateur>/TXM/R\libraries ».

La configuration des options de lancement de R (et Rserve) est accessible depuis la page de préférences avancées de R (TXM > Avancé > Moteur statistique). Pour plus d’informations sur R, voir les pages suivantes :

Options de R : http://www.r-project.org
Options de Rserve : http://rforge.net/Rserve/doc.html\#start

9.5.5 Exemple de session de travail utilisant R

9.5.5.1 Affichage de l’histogramme des fréquences d’un index de lemmes calculé avec R

L’objectif de cette session exemple est d’afficher l’histogramme des fréquences des 10 lemmes de noms les plus fréquents du corpus Discours :

construire l’Index des lemmes de noms :
commande Index avec les paramètres :
corpus : DISCOURS
requête : [pos=“N.*”]
propriété : lemma
Vmax: 10
envoyer l’Index dans R :
dans le menu contextuel de l’icone de résultat d’Index, descendante de l’icone du corpus DISCOURS dans la vue Corpus et nommée « [pos=”N.*”]:lemma », lancer la commande « Envoyer vers R »
l’icone de résultat d’Index doit recevoir une lettre R rouge pour confirmer le transfert
repérer et copier le nom de l’objet R créé dans la console : par exemple « Index1 »
ouvrir la perspective R en cliquant sur le bouton « R » de la barre d’outils des perspectives
démarrer une nouvelle session en cliquant sur le bouton « Nouvelle session » de la barre d’outils
copier le script R suivant dans l’éditeur de texte nommé « sessionX.R » (où « X » est le numéro de la session):

svg(“/tmp/test.svg”)

barplot(t(IndexN$data), space=c(1,35), horiz=F, las=2, beside=T)

dev.off()

éditer la chaine « IndexN » en collant le nom de l’objet R créé lors du transfert vers R (par exemple « Index1 »)
exécuter le script en cliquant sur le bouton « Exécuter » de la barre d’outils (flèche verte)
vérifier le résultat en ouvrant le fichier « /tmp/test.svg » dans votre navigateur à partir du gestionnaire de fichiers.

9.5.5.2 Affichage de l’histogramme directement dans TXM avec un script Groovy

Vous pouvez afficher le fichier SVG généré directement dans TXM en double-cliquant sur son icone depuis la vue « Fichier » (dont l’onglet est par défaut situé à côté de celui de la vue « Corpus »).

Vous pouvez également afficher directement le fichier SVG en exécutant le script Groovy suivant :

import org.txm.rcpapplication.commands.*

monitor.syncExec(new Runnable() { @Override

public void run() { OpenSVGGraph.OpenSVGFile(“/tmp/test.svg”, “histogram plot”) }

});

d’abord copier le script dans un éditeur de texte (menu « Fichier > Nouveau fichier »);
ensuite sélectionner le texte du script ;
enfin, lancer « Groovy / Exécuter la sélection de texte » depuis le menu contextuel de l’éditeur.

Si l’éditeur de texte est ouvert sur un fichier du dossier « $HOME/scripts/user » ayant une extension « .groovy », alors vous pouvez exécuter le script directement par le menu contextuel de l’éditeur « Groovy > Exécuter le Script ».

9.5.5.3 Exécution du script R et de l’affichage de l’histogramme depuis un seul script Groovy

Il est possible d’assembler le script R et le script d’affichage du SVG dans un seul script Groovy :

dans un éditeur de texte ouvert sur un fichier du dossier « $HOME/scripts/user » ayant une extension « .groovy », copier le script Groovy suivant :

import org.txm.rcpapplication.commands.*

import org.txm.stat.engine.r.RWorkspace

def r = RWorkspace.getRWorkspaceInstance()

r.eval(““”

##### début du script R #####

svg(“/tmp/test.svg”)

barplot(t(IndexN\$data), space=c(1,35), horiz=F, las=2, beside=T)

dev.off()

##### fin du script R #####

“““)

import org.txm.rcpapplication.commands.*

monitor.syncExec(new Runnable() { @Override public void run() { OpenSVGGraph.OpenSVGFile(“/tmp/test.svg”, “histogram plot”) }

});

remplacer le nom du symbole « IndexN » par celui de l’Index transféré à R (par exemple « Index1 ») ;
enfin, lancer “Groovy / Exécuter le Script” dans le menu contextuel de l’éditeur.

9.5.5.4 Saisie du nom de l’index depuis une boite de dialogue à l’aide d’une macro TXM

Pour faciliter la mise à jour du nom du symbole dans le script, on peut le faire saisir dans une boite de dialogue en transformant le script en macro TXM :

dans un éditeur de texte ouvert sur le fichier « testMacro.groovy » du dossier « $HOME/scripts/macro », copier le script Groovy suivant :

import org.kohsuke.args4j.*

import groovy.transform.Field

import org.txm.rcpapplication.swt.widget.parameters.ParametersDialog

import org.txm.rcpapplication.commands.*

import org.txm.stat.engine.r.RWorkspace

@Field @Option(name=“symbol_name”,usage=“symbol name of the Index to use”, widget=“String”, required=true, def=“Index1”)

def symbol_name

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

def r = RWorkspace.getRWorkspaceInstance()

r.eval(““”

##### début du script R #####

svg(“/tmp/test.svg”)

barplot(t(${symbol\_name}\\$data), space=c(1,35), horiz=F, las=2, beside=T)

dev.off()

##### fin du script R #####

“““)

monitor.syncExec(new Runnable() {

@Override

public void run() { OpenSVGGraph.OpenSVGFile(“/tmp/test.svg”, “histogram plot”) }

});

ouvrir la vue « Macro » (menu principal « Affichage > Vues > Macro »)
double-cliquer sur l’icone du fichier « test » dans la vue Macro pour l’exécuter :
dans la boite de dialogue, saisir le nom de symbole voulu dans le champ « symbol_name » et presser « Run ».

9.5.5.5 Récupération du nom de l’index directement depuis la macro

    Pour aller plus loin encore dans la simplification de la
    désignation de l'index concerné, il est possible d'obtenir le
    nom de l'index transféré depuis la macro en désignant l'index
    dans la vue Corpus :

dans un éditeur de texte ouvert sur le fichier « testMacro.groovy » du dossier « $HOME/scripts/macro », copier le script Groovy suivant :

import org.txm.rcpapplication.commands.*

import org.txm.stat.engine.r.RWorkspace

import org.txm.functions.vocabulary.*

if (!corpusViewSelection || !(corpusViewSelection instanceof Vocabulary)) {

println “Error: this macro should be run with an Index selected”

return

}

def symbol_name = corpusViewSelection.getSymbol()

def r = RWorkspace.getRWorkspaceInstance()

r.eval(““”

##### début du script R #####

svg(“/tmp/test.svg”)

barplot(t(${symbol\_name}\\$data), space=c(1,35), horiz=F, las=2, beside=T)

dev.off()

##### fin du script R #####

“““)

monitor.syncExec(new Runnable() {

@Override

public void run() { OpenSVGGraph.OpenSVGFile(“/tmp/test.svg”, “histogram plot”) }

});

sélectionner l’icone d’Index résultat dans la vue Corpus pour lequel vous souhaitez afficher l’histogramme (ne pas oublier de transférer l’Index vers R au préalable) ;
ouvrir la vue « Macro » (menu principal « Affichage > Vues > Macro ») ;
double-cliquer sur le fichier macro pour l’exécuter.

Pour lancer successivement la même macro sur plusieurs résultats d’Index, une configuration pratique consiste à afficher la vue Macros dans le panneau de gauche avec la vue Corpus. Par exemple, le moitié supérieure pour la vue Corpus et le moitié inférieure pour la vue Macros (pour déplacer la vue Macros, faire glisser son onglet dans le panneau de gauche).

9.5.6 Description des principaux objets TXM transférés à R

un objet Lexique est transféré sous forme d’une matrice (matrix) d’un seul vecteur colonne (vector) de fréquences (numeric) dont chaque ligne est nommée par la valeur de la propriété décomptée.
un objet Index issu d’un corpus ou d’un sous-corpus est transféré sous forme d’une liste (data.frame) contenant un objet nommé data . L’objet data est une matrice d’un seul vecteur colonne de fréquences dont chaque ligne est nommée par la valeur de la propriété décomptée ou par la concaténation des valeurs des propriétés décomptées quand il y en a plusieurs (dans ce cas les valeurs sont séparées par le caractère souligné : « _ »).
un objet Index issu d’une partition est transféré sous forme d’une liste contenant un objet nommé data . L’objet data est une matrice d’autant de vecteurs colonnes de fréquences que de parties. Chaque ligne est nommée par la valeur de la propriété décomptée ou par la concaténation des valeurs des propriétés décomptées quand il y en a plusieurs (dans ce cas les valeurs sont séparées par le caractère souligné : « _ »). La première colonne contient les marges de lignes, elle est nommée F.
un objet Tablelexicale, issu d’une partition ou d’un index de partition est transféré sous forme d’une matrice d’autant de vecteurs colonnes de fréquences que de parties. Chaque ligne est nommée par la valeur de la propriété décomptée ou par la concaténation des valeurs des propriétés décomptées quand il y en a plusieurs (dans ce cas les valeurs sont séparées par le caractère souligné : « _ »).
un objet Concordance est transféré sous forme d’une liste contenant des objets nommés data, leftcontext et rightcontext. L’objet data est une matrice de 4 vecteurs colonnes de chaînes nommés refs, leftcontext, keywords et rightcontext. Ils contiennent respectivement, les références, les contextes gauches, les pivots et les contextes droits. Les objets leftcontext et rightcontext contiennent la taille en mots des contextes gauche et droit.
un objet Corpus est transféré sous forme d’une liste contenant des objets de base stockant les codes des valeurs de propriétés de mots pour chaque occurrence dans l’ordre des textes du corpus (data), ainsi que les dictionnaires de ces valeurs (wordlex pour le dictionnaire des formes et idlex pour le dictionnaire des identifiants de mots).

Si les mots du corpus ont été annotés, les valeurs de ces annotations sont stockées dans autant de dictionnaires supplémentaires que nécessaire nommés frposlex, frlemmalex (c’est-à-dire « code de langue|nom de propriété|lex » pour des annotations TreeTagger) ou bien de n’importe quel nom d’annotation supplémentaire. L’objet data est une matrice de vecteurs colonnes pour chaque propriété de mot. Les colonnes sont nommées par les noms de propriétés. Les positions de début et de fin de textes sont stockées dans les vecteurs $struct$text$start et $struct$text$end de l’objet R créé.