Outils pour convertir des dictionnaires

Pour faciliter la lecture, nous avons rassemblé dans cette page tous les outils disponibles (à notre connaissance) pour permettre des conversions entre les différents formats de dictionnaires, y compris ceux qui ne sont pas issus du projet “Polyglotte”. Le tableau ci-dessous fait la synthèse des conversions possibles et des scripts ou logiciels les permettant. Les scripts tab2wb (?), wb2tab (?), apertium2tabdict.sh et apertium2tabling.sh, ainsi que le logiciel Linguae, sont issus du projet “Polyglotte”.

1/ Ces scripts apertium2tabdict.sh et apertium2tabling.sh ont une dépendance : lt-expand, qui doit être préalablement installée (paquet lttoolbox disponible notamment sous Linux Ubuntu hardy et Intrepid)

2/ Ils permettent de sortir 6 lexiques (lexique total, lexique sans nom propre, lexique des noms propres, dans les deux sens “langue1-langue2” et “langue2-langue1”). Les lexiques des noms propres ne comportent que les noms propres qui diffèrent entre les deux langues.

3/ architecture des lexiques obtenus :
a) apertium2tabdict.sh : mot langue 1 | [code grammatical mot langue 1] mot langue 2 [code grammatical mot langue 2]
(cette architecture, avec le mot seul dans le premier champ, convient à la fonction de scan des logiciels StarDict et QStarDict.)
b) apertium2tabling.sh : mot langue 1 [code grammatical mot langue 1] | mot langue 2 [code grammatical mot langue 2]
(cette autre architecture, équilibrée, convient au logiciel Linguae, notamment pour la création de lexiques par héritage)

4/ procédure
- téléchargez le script apertium2tabdict.sh ou apertium2tabling.sh et placez le dans le répertoire qui vous convient; rendez-le exécutable.
- installer le paquet lttoolbox (si ce n'est déjà fait) pour disposer de lt-expand.
- récupérer un document xml Apertium de type “apertium-l1-l2.l1-l2.dix” sur le svn sourceforge d'Apertium et placez-le dans le répertoire où vous avez mis le script.
- nettoyez votre bureau (les lexiques obtenus seront placés sur le bureau)
- dans un terminal, placez-vous dans le répertoire où vous avez mis le script (commande “cd” + chemin du répertoire)
- lancez la commande : ”./apertium2tabdict.sh apertium-l1-l2.l1-l2.dix dicotemp” ou ”./apertium2tabling.sh apertium-l1-l2.l1-l2.dix dicotemp” (en remplaçant apertium-l1-l2.l1-l2.dix par le fichier apertium que vous avez téléchargé et que vous voulez convertir).

5/ lexiques obtenus sur le bureau :

total.tab : lexique complet issu d'Apertium dans le sens originel des langues du document Apertium. Il pourra être renommé “lexicapertium-l1-l2.tab”

totalinv.tab : lexique complet issu d'Apertium dans le sens inverse des langues du document Apertium. Il pourra être renommé “lexicapertium-l2-l1.tab”

snp.tab : lexique sans nom propre issu d'Apertium dans le sens originel des langues du document Apertium. Il pourra être renommé “lexicapertium-l1-l2_snp.tab”

snpinv.tab : lexique sans nom propre issu d'Apertium dans le sens inverse des langues du document Apertium. Il pourra être renommé “lexicapertium-l2-l1_snp.tab”

npdiff.tab : lexique des noms propres (à l'exclusion de ceux qui sont identiques entre les deux langues) issu d'Apertium dans le sens originel des langues du document Apertium. Il pourra être renommé “lexicapertium-l1-l2_np.tab”

npdiff.tab : lexique des noms propres (à l'exclusion de ceux qui sont identiques entre les deux langues) issu d'Apertium dans le sens originel des langues du document Apertium. Il pourra être renommé “lexicapertium-l2-l1_np.tab”

Par convention, on ajoute “_ling” aux noms des lexiques obtenus avec le script apertium2tabling.sh

les fichiers DOCTEMP (sur le bureau) et dicotemp (dans le même répertoire que le script) sont des documents temporaires qu'il suffit de supprimer dès que le script a fini son ouvrage.

6/ Important : renommer et classer les lexiques obtenus avant de lancer de nouveau le script sur un autre document Apertium, sinon votre premier travail sera écrasé…

7/ Les lexiques obtenus peuvent être ouverts directement par certains logiciels (comme Linguae). Ils peuvent être aussi facilement convertis au format “dict” (pour StarDict et QStarDict) avec “stardict-editor” (ou Linguae).

Exécutable en ligne de commande, qu'on trouve dans /usr/lib/stardict-tools/ après installation du paquet stardict-tools . Il permet de décompiler. La syntaxe est : /usr/lib/stardict-tools/stardict2text mondico.ifo

Exécutable en ligne de commande, qu'on trouve dans /usr/lib/stardict-tools/ après installation du paquet stardict-tools. Il permet de compiler. La syntaxe est : /usr/lib/stardict-tools/tabfile mondico.txt

http://sourceforge.net/project/showfiles.php?group_id=95155&package_id=160978 Il convertit de : dictd, dsl, sdict, stardict, xdxf vers dictd (expérimental), stardict, xdxf. Pour le compiler, téléchargez l'archive et suivre les instructions du fichier README.

Exemple d'utilisation (conversion d'un fichier xdxf (XML) en fichier Stardict) :

./makedict -i xdxf -o stardict exemple.xdxf

Le seul outil permettant de convertir les fichiers de babylon de type ”.bgl”. (disponible dans les dépôts sous ubuntu). Il convertit des dictionnaires de Babylon, Freedict, Sdictionary et Stardict vers les dictionnaires au format DICT, plain text et StarDict.

Exemple : dictconv -o dico.ifo dico.BGL

Convertisseur de dictionnaires wb en csv (avec tabulation comme séparateur). Le format csv est lu par la plupart des tableurs : openOffice Calc, Excel, etc… Il est aussi un bon point de départ pour une conversion vers un autre format de dictionnaire.

• wb2tab.c

#include <stdio.h>
 
int main(int narg, char* argv) {
char c;
int i=0, drapeau=1;
while ((c = getchar()) != EOF){
    i++;
    if(i==32){
        drapeau=1;
        putchar('\t');
    }
    if(i==85){
        putchar('\n');
        i=1;
        drapeau=1;
    }
    if (c=='\x00'){
        drapeau=0;
    }
    if(drapeau==1){
        putchar(c);
    }
}
putchar('\x0A');
return 0;
}

• Compilation (installer build-essential):

gcc -o wb2tab wb2tab.c

• Exécution:

./wb2tab <fichier.wb >fichier.csv

#include <stdio.h>
 
int main(int narg, char* argv) {
char c;
int i=0, drapeau=0;
while ((c = getchar()) != EOF){
	if(c=='\n'){
		i++;
		while(i<86){
			putchar('\x00');
			i++;
		}
		i=0;
		drapeau=0;
	}
	else if(c=='\t'){
		i++;
		while(i<32){
			putchar('\x00');
			i++;
		}
		drapeau=1;
	} else if(drapeau && (i<85)||(!drapeau && (i<31))){
		i++;
		putchar(c);
	}
}
return 0;
}

<?xml version="1.0" encoding="UTF-8" ?>
<xdxf lang_from="FRE" lang_to="FRE" format="visual">
<full_name>Nom du dictionnaire</full_name>
<description>blablabla </description>

Compilation :

 gcc -o tab2xdxf tab2xdxf.c

et exécution :

./tab2xdxf <DicoAvant.txt >DicoApres.xdxf

#include <stdio.h>
 
 
int entete(void){
	return 0;
}
 
int baliseouvrante(char* t){
	int i=0;
	putchar('<');
	while(t[i]!='\0'){
		putchar(t[i]);
		i++;
	}
	putchar('>');
	return 0;
}
 
int balisefermante(char* t){
	int i=0;
	putchar('<');
	putchar('/');
	while(t[i]!='\0'){
		putchar(t[i]);
		i++;
	}
	putchar('>');
	putchar('\n');
	return 0;
}
 
int baliseautofermante(char* t){
	int i=0;
	putchar('<');
	while(t[i]!='\0'){
		putchar(t[i]);
		i++;
	}
	putchar('/');
	putchar('>');
	putchar('\n');
	return 0;
}
 
int balises(char* t){
	baliseouvrante(t);
	balisefermante(t);
	return 0;
}
 
int main(int narg, char** argv) {
	int i, drapeau=1, drapeauparenthese=0;
	char* def="ar";
	char* par="tr";	
	char* mot="k";
	char* sen="sens";
	char* bq="blockquote";
	char* tra="traduction";
	char* syn="synonyme";
	char* it="i";
	char* gras="b";
	char* kref="kref";
	char c;
	for(i=0;i<narg;i++){
		while(argv[i]!='\0'){
			i++;
		}
	}
	entete();
	baliseouvrante(def);
	putchar('\n');
	baliseouvrante(mot);	
	while ((c = getchar()) != EOF){
		if(c=='\t'){
			drapeau=0;
			balisefermante(mot);
		}else if (c=='\n'){
			putchar('\n');		
			balisefermante(def);
			baliseouvrante(def);
			putchar('\n');
			baliseouvrante(mot);
			drapeau=1;
		}else{
			putchar(c);
		}
	}
	putchar('\x0A');
	return 0;
}

cf ici. tidy (disponible dans dépôts dans les distributions debian, ubuntu, …) permet notamment la conversion de HTML en XHTML : ce qui permet ensuite d'utiliser des feuilles XSL, par exemple pour convertir en XDXF.

tidy -clean --drop-proprietary-attributes yes --drop-font-tags yes --drop-empty-paras yes -utf8 --doctype omit -numeric -asxhtml -o exemple.xhtml exemple.html

Un petit utilitaire en python, qui transforme le format microsoft rtf en xml. il est téléchargeable ici (j'ai dû télécharger le paquet python-profiler pour que ça marche). Problème avec les caractères non ascii ?

rtf2xml monfichier.rtf

(ou “comment échapper aux bidouillages microsoftiens”)…

Lorsqu'on récupère des lexiques originellement au format doc ou html, composés de caractères non-latins, on risque d'être confronté au problème suivant : les caractères visiblement non-latins peuvent s'avérer être des caractères latins, affublés d'une police comme “symbol”. Pour remédier à ça, voici un petit programme en C qui convertit ces caractères en l'unicode correspondant, à compiler ( gcc -o convertcarac convertcarac.c) et exécuter :

./convertcarac lexiquecarac.txt <avant.txt >apres.txt

avec lexiquecarac.txt un fichier de conversion des caractères (encodé en utf-8), dont voici un mini-exemple :

V   ω
a   α
b   β

avant.txt quant à lui est un fichier texte de la même structure que décrite plus haut (paragraphe tabfile), encodé lui aussi en utf-8 :

apo   loin de
agV   conduire

le code convertira les éléments de la première colonne uniquement. apres.txt devrait contenir après exécution :

απο   loin de
αγω   conduire

Le code :

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define ALPHABETMAX 100
 
int creetableau(FILE* fichier , char tab[ALPHABETMAX][2][5], int* taille){
	int i=0, j=0, k=0, drapeau=0;
	char c;
	while((c = getc(fichier)) != EOF){
		if(c=='\t'){
			drapeau=1;
			j=1;
			k=0;		
		}else 
		if(c=='\n'){
			drapeau=0;
			j=0;
			i++;
			k=0;			
		}else{
			tab[i][j][k]=c;
			tab[i][j][++k]='\0';
		}
	}
	*taille=i;
	return 0;
}
 
int apptableau(int taille, char d[5], char tab[ALPHABETMAX][2][5], int* ind){
	int res=-1, i=0, victoire=1, j=0;	
	for(i=0;i<taille;i++){
		victoire=1;
		j=0;
		while( (d[j]!='\0') && (tab[i][0][j]!='\0') ){
			if (d[j]!=tab[i][0][j]){
				victoire=0;
				break;
			}
			j++;
		}
		if (victoire && (j>0)){
			*ind=i;
			res=1;
		}
	}
	return res;
}
 
 
int main(int narg, char** argv) {
	char tab[ALPHABETMAX][2][5]; 
	int i=0, j=0, k=0, drapeau=1, ind=0, res=0, taille=0;
	char c,e;
	char d[5];
	FILE* lexique;
	lexique=fopen(*(argv+1),"r");
	if(lexique==NULL){
		printf("Pas trouvé de fichier.\n");
	}
	res=creetableau(lexique, tab, &taille);
	fclose(lexique);
	while ((c = getchar()) != EOF){
		if (c=='\n'){
			putchar('\n');		
			drapeau=1;
		}else if (c=='\t'){
			putchar('\t');		
			drapeau=0;
		}else if (drapeau){
			i=1;
			*d=c;
			if((unsigned char)c >192){ /* unicode sur 2 octets*/
				e = getchar();
				*(d+(i++))=e;
			}
			if((unsigned char)c >224){/* unicode sur 3 octets*/
				e = getchar();
				*(d+(i++))=e;			
			}
			if((unsigned char)c >240){/* unicode sur 4 octets*/
				e = getchar();
				*(d+(i++))=e;			
			}
			*(d+i)='\0';
			if ((res=apptableau(taille,d,tab,&ind))==1){
				k=0;
				while(tab[ind][1][k] !='\0'){
					putchar(tab[ind][1][k]);
					k++;
				}		
			}else{
				i=0;
				while(*(d+i)!='\0'){			
					putchar(*(d+(i++)));
				}
			}
		}else{
			putchar(c);
		}
	}
	putchar('\x0A');
	return 0;
}

Script Python qui permet à partir de la table csv du projet “lexique” de shtooka de créer des csv importables par anki.

• Récupérer la table multi-lingue ici.
• La sauvegarder sous le nom “table.csv”.
• Appeler csvshtooka2ankicard.py dans le terminal :

./csvshtooka2ankicard.py table.csv

• On récupère dans le même répertoire des fichiers csv bilingues (autant que de langues disponibles), prêts à l'import sous anki (en spécifiant '\t' comme séparateur).

Le code de csvshtooka2ankicard.py :

#!/usr/bin/python
 
import string
import sys
import csv
 
delim='\t'
def readCsv(csvFilename, delim):
	dialect = csv.Sniffer().sniff(open(csvFilename, 'r').read())
	return csv.reader(open(csvFilename, 'r'), dialect=dialect, delimiter=delim)
 
if len(sys.argv) < 2:
	print 'Usage: %s file.csv' % sys.argv[0]
elif len(sys.argv) >2:
	print 'Usage2: %s file.csv' % sys.argv[0]
else:
	csvFile=sys.argv[1]
	data = readCsv(csvFile,delim)
	fichiersortie=[]
	for ir, row in enumerate(data):
		if ir==0:
			for ic, column in enumerate(row):
				if ic>3:
					nomfichier=column
					fichiersortie.append(csv.writer(open(nomfichier + ".csv", "wb"),delimiter=delim))
		elif ir>0:
			if row[2]=="":
				pivot=row[3]
			else:
				pivot=row[3]+" ("+row[2]+")"
			for ic, column in enumerate(row):
				if ic>3:
					if column<>"":
						fichiersortie[ic-4].writerow([pivot,column])

Un petit utilitaire qui permet de convertir un (ou des) fichiers csv en un document openOffice ods (tableur). (utilise la librairie ooolib -incluse dans le zip-)
À télécharger ici.

Exemple : csv2ods.py -d \t fichier.ods fichier1.csv fichier2.csv … fichierN.csv

Script créé par Guido Vicino et modifié par polyglotte (ajout du choix du délimiteur).

• http://guidovicino.com/blog/2007/04/18/csv2odspy/csv2ods (it)

Conversion d'un encodage à un autre :

iconv -t UTF-8 -f ISO-8859-1 fichierOrigine.txt >fichierSortie.txt

XML-Twig est une bibliothèque écrite en Perl, permettant des traitements de très gros fichiers XML : notamment, xml_split -s 30Mb -b wiki mongrosfichier.xml permet de tronçonner en fichier de 30 Mo mon fichier de départ. Se trouve en paquet sous toutes les bonnes distributions GNU/Linux; sous ubuntu, c'est ici.