Jona: /* Utilisation comme module depuis Python */

2017-03-10T13:22:05Z

Utilisation comme module depuis Python

Bech: Lien page anglaise

2014-10-07T13:09:22Z

Lien page anglaise

Polo: moved Application Lttoolbox to Application lttoolbox

2013-02-19T16:18:16Z

moved Application Lttoolbox to Application lttoolbox

Polo: /* Utilisation comme bibliothèque en C++ */

2013-02-19T16:16:53Z

Utilisation comme bibliothèque en C++

Bech: Création page

2012-05-01T16:29:32Z

Création page

New page

Vous pouvez utiliser [[Lttoolbox_(français)|lttoolbox]] comme bibliothèque en C++ avec <code>#include <lttoolbox/fst_processor.h></code>, et avec un peu plus de travail, vous pouvez aussi l'utiliser depuis Python.

== Utilisation comme bibliothèque en C++ ==

Pour cet exemple vous aurez besoin de deux fichiers, <code>test.dix</code>:

<pre>
<dictionary>
<alphabet/>
<sdefs>
<sdef n="n"/>
<sdef n="pl"/>
</sdefs>
<section id="main" type="standard">
<e><p><l>cars</l><r>car<s n="n"/><s n="pl"/></r></p></e>
</section>
</dictionary>
</pre>

et <code>test.cc</code>:

<pre>
#include <stdio.h>
#include <string>
#include <iostream>

#include <lttoolbox/fst_processor.h>
#include <lttoolbox/lt_locale.h>
#include <lttoolbox/ltstr.h>

using namespace std;

FSTProcessor fstp;

int main(int argc, char **argv)
{
if(argc < 2) {
wcout << L"Veuillez spécifier un transducteur" << endl;
exit(-1);
}

LtLocale::tryToSetLocale();
FILE *t_rl = fopen(argv[1], "r");

fstp.load(t_rl);
fclose(t_rl);
fstp.initBiltrans();

wstring input = L"^car<n><pl>$";
wstring trad = fstp.biltrans(input);

wcout << entrée << L" --> " << trad << endl;

return 0;
}
</pre>

Compilez les deux fichiers :

<pre>
$ lt-comp rl test.dix test_rl.bin
main@standard 6 5

$ g++ -Wall test.cc -o test -llttoolbox3
</pre>

Et ensuite testez :

<pre>
$ ./test test_rl.bin
^car<n><pl>$ --> ^cars$
</pre>

== Utilisation comme module depuis Python ==

Cet exemple est basé sur la manière dont [[libvoikko (a traduire ?)]] utilise lttoolbox pour l'analyse. On fait une bibliothèque C++ qui expose n'importe quelle fonction lttoolbox dont on a besoin pour Python, et une petite classe Python qui rend l'appel de ces fonctions un peu plus pythonique.<ref>Une alternative pourrait être d'inclure Python.h dans le code C++, et définir une classe Python complète à partir de là, à la manière dont [https://launchpad.net/pylibtextcat pylibtextcat]/[https://github.com/bbqsrc/pylibtextcat py3libtextcat] crée une classe Python pour la bibliothèque C.</ref>

Écrivez les fichiers qui suivent :

libltpy.h:
<pre>
#include <lttoolbox/fst_processor.h>

class Analyser {
public:
Analyser(const std::string & directoryName) throw(exception);
wstring analyse(wstring const &word);
private:
FSTProcessor fst;
};
</pre>

libltpy.cc:
<pre>
#include "libltpy.hpp"
#include <lttoolbox/fst_processor.h>
#include <lttoolbox/lt_locale.h>

using namespace std;

Analyser::Analyser(const string & analyserpath) throw(exception) {
FILE * file = fopen(analyserpath.c_str(), "r");
if (!file) {
cerr << "Impossible d'ouvrir le fichier analyseur " << analyserpath << endl;
throw exception();
}
fst.load(file);
fclose(file);
fst.setCaseSensitiveMode(false);
fst.setDictionaryCaseMode(true);
fst.initBiltrans();
}

wstring Analyser::analyse(wstring const &word) {
pair <wstring,int> analysis = fst.biltransWithQueue(word, false);
// Le 'faux' signifie que les ^ ou $ ne sont pas nécessaires en entrée/sortie
if (analysis.second == 0) {
return analysis.first;
}
else {
// une correspondance partielle :
return L"@"+word;
}
}

extern "C" wstring * analyse(Analyser * a, const wchar_t * word) {
// Il semble que Python peut seulement envoyer des wchar_t*, mais on a besoin d'une wstring
size_t wlen = wcslen(word);
if (wlen == 0) {
// éviter un bug dans biltransWithQueue:
return 0;
}
wstring inputString = L"";
for (size_t i = 0; i < wlen; i++) {
inputString.append(1, word[i]);
}
wstring * out = new wstring(a->analyse(inputString));
return out;
}

EXTERN void free_analyses(wstring * analyses) {
delete analyses;
}

extern "C" Analyser * init(const char ** error, const char * path) {
LtLocale::tryToSetLocale();
Analyser * a = 0;
try {
a = new Analyser(path);

}
catch (exception & e) {
delete a;
a = 0;
*error = e.what();
return 0;
}
*error = 0;
return a;
}

extern "C" void terminate(Analyser * a) {
delete a;
}
</pre>

lt.py:
<pre>
# -*- coding: utf-8 -*-
from ctypes import byref, CDLL, c_char_p, c_wchar_p, c_void_p, POINTER

class FST(object):
def __init__(self, libpath, fstpath):
self.__lib = CDLL(libpath)

self.__lib.init.argtypes = [POINTER(c_char_p), c_char_p]
self.__lib.init.restype = c_void_p

self.__lib.terminate.argtypes = [c_void_p]
self.__lib.terminate.restype = None

self.__lib.analyse.argtypes = [c_void_p, c_wchar_p]
self.__lib.analyse.restype = POINTER(c_wchar_p)

error = c_char_p()
self.__handle = self.__lib.init(byref(error), fstpath)
if error.value != None:
self.__handle = 0
raise Exception(u"Erreur d'initialisation de fst : " + unicode(error.value, "UTF-8"))

def __del__(self):
if (self.__handle != 0):
self.__handle = 0
class DummyLib:
def __getattr__(obj, name):
raise Exception("Tentative d'utilisation de la bibliothèque après l'appel de terminate()")
self.__lib = DummyLib()

def analyse(self, word):
ana_p = self.__lib.analyse(self.__handle, word)
if ana_p:
analysis = ana_p.contents.value
else:
analysis = ""
self.__lib.free_analyses(ana_p)
return analysis
</pre>

Compilez les fichiers C++ afin d'obtenir un fichier comme libltpy.so. Les commandes qui suivent on travaillé pour moi :

<pre>
g++ -DGCC_VISIBILITY=1 -g -O2 -fvisibility=hidden -I/usr/local/include/lttoolbox-3.2 -I/usr/local/lib/lttoolbox-3.2/include -c libltpy.cpp -fPIC -DPIC -o libltpy.o

g++ -fPIC -DPIC -shared libltpy.o -Wl,-rpath -Wl,/usr/local/lib -Wl,-rpath -Wl,/usr/local/lib -L/usr/local/lib /usr/local/lib/liblttoolbox3.so -Wl,-soname -Wl,libltpy.so.0 -o libltpy.so
</pre>

Quoi qu'il en soit, si vous utilisez des outils automatiques, vous avez pratiquement juste besoin de ce qui suit dans votre Makefile.am :

<pre>
lib_LTLIBRARIES = libltpy.la
libltpy_la_SOURCES = libltpy.cpp
libltpy_la_LDFLAGS = $(LTTOOLBOX_LIBS)
</pre>

ensuite <code>autogen.sh</code> et <code>make libltpy.la</code> (voir [[#Exemples sur des mots réels]]).

Alors utilisez-le comme :

<pre>
import lt
fst = lt.FST("libltpy.so", "analyser.bin")
print fst.analyse(u"cars") # devrait afficher car<n><pl>
</pre>

== Exemples sur des mots réels ==

* apertium-transfer utilise lttoolbox depuis le C++ pour examiner des mots dans le bidix
** http://apertium.svn.sourceforge.net/viewvc/apertium/trunk/apertium/apertium/transfer.cc?view=markup

* libvoikko utilise lttoolbox depuis le C++ pour analyser des mots, et aussi fabrique un module Python :
** http://sourceforge.net/apps/trac/voikko/browser/trunk/libvoikko/src/morphology/LttoolboxAnalyzer.cpp
** http://sourceforge.net/apps/trac/voikko/browser/trunk/libvoikko/src/morphology/interface.cpp
** http://sourceforge.net/apps/trac/voikko/browser/trunk/libvoikko/python/libvoikko.py

== Notes ==
<references/>

[[Category:lttoolbox]]
[[Category:Morphological analysers]]
[[Category:Development]]
[[Category:Documentation en français]]

← Older revision		Revision as of 13:09, 7 October 2014
Line 1:		Line 1:
			[[Lttoolbox API\|In English]]

	Vous pouvez utiliser [[Lttoolbox_(français)\|lttoolbox]] comme bibliothèque en C++ avec <code>#include <lttoolbox/fst_processor.h></code>, et avec un peu plus de travail, vous pouvez aussi l'utiliser depuis Python.		Vous pouvez utiliser [[Lttoolbox_(français)\|lttoolbox]] comme bibliothèque en C++ avec <code>#include <lttoolbox/fst_processor.h></code>, et avec un peu plus de travail, vous pouvez aussi l'utiliser depuis Python.

@@ Line 80: / Line 80: @@
 Écrivez les fichiers qui suivent :
-libltpy.h:
+libltpy.hpp:
 <pre>
 #include <lttoolbox/fst_processor.h>
@@ Line 93: / Line 93: @@
 </pre>
-libltpy.cc:
+libltpy.cpp:
 <pre>
 #include "libltpy.hpp"
@@ Line 141: / Line 141: @@
 }
-EXTERN void free_analyses(wstring * analyses) {
+extern "C" void free_analyses(wstring * analyses) {
 	delete analyses;
 }

← Older revision	Revision as of 16:18, 19 February 2013
(No difference)

@@ Line 3: / Line 3: @@
 == Utilisation comme bibliothèque en C++ ==
-Pour cet exemple vous aurez besoin de deux fichiers, <code>test.dix</code>:
+Pour cet exemple, vous aurez besoin de deux fichiers : <code>test.dix</code>
 <pre>
@@ Line 18: / Line 18: @@
 </pre>
-et <code>test.cc</code>:
+et <code>test.cc</code>.
 <pre>
@@ Line 65: / Line 65: @@
 </pre>
-Et ensuite testez :
+Puis testez :
 <pre>

Application lttoolbox - Revision history

Jona: /* Utilisation comme module depuis Python */

Bech: Lien page anglaise

Polo: moved Application Lttoolbox to Application lttoolbox

Polo: /* Utilisation comme bibliothèque en C++ */

Bech: Création page