Discussion :

[hizoka]

en même temps pas sur d'utiliser tout ça très souvent :p

Mais en effet c'est ce que j'ai lu dans la doc aussi.

M'enfin dans 98% des cas tr (simple en python3) marche bien
Surtout si on passe par un dictionnaire ayant les traductions, je pense que ca doit passer.


Je suis tombé la dessus :
http://qt.developpez.com/doc/4.7/qui...eChangeEnabled
ca n'aiderait pas pour la traduction dynamique ?

[tyrtamos]

Tu peux adopter la règle suivante: utiliser la version simple (tr ou trUtf8) partout, sauf pour écrire une classe ayant des mots à traduire et que tu es susceptible de sous-classer!

Par ailleurs, je découvre des choses curieuses. J'ai essayé de simplifier la version longue, mais il y a une limite, parce que pylupdate4 trouve les lignes à traduire par une simple analyse de texte.

Voilà, par exemple, une simplification qui marche (code Python 2.7 en utf-8):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
translate = QtGui.QApplication.translate
UnicodeUTF8 = QtGui.QApplication.UnicodeUTF8
translate("Fenetre", u"bouton éèçàùôï", None, UnicodeUTF8)

La 3e ligne sera bien trouvée par pylupdate4 (grâce à "translate") comme une ligne à traduire, et la prendra avec le bon encodage (grâce à "UnicodeUTF8"). Mais il suffit que j'utilise "translat" pour que la ligne ne soit plus trouvée!

C'est d'ailleurs un peu dans le même esprit que pyuic4 utilise "_translate".

Pour l'instant, je ne sais pas faire mieux, mais ça devient supportable. Si on disposait d'un "préprocesseur" comme avec le C, on pourrait simplifier beaucoup plus en provoquant un traitement préalable du texte...

Pour "QUiLoader": je ne connaissais pas. Cependant, si je suis content d'avoir réussi le changement dynamique de la langue en cours d'exécution, je ne crois pas que ça mérite autant d'effort. Les principaux programmes que je connais qui permettent le changement de la langue, demandent un redémarrage du programme, et ça ne me semble pas déplacé. Et pour éviter de redemander le choix à chaque lancement, on le conserve dans le home de l'utilisateur (c'est une solution multiplateforme).

Maintenant, je m'occupe du dictionnaire "phrasebooks".

[tyrtamos]

Bonjour,

Concernant le problème cité ci-dessus, je crois que j'ai trouvé une solution, et j'aimerais bien que tu me donnes ton avis.

Je rappelle le problème. Pour définir les chaines à traduire, on utilise souvent tr("chaine") ou trUtf8("chaine") comme avec Qt4, et c'est la solution la plus simple.

Mais riverbank (PyQt4) dit 2 choses:
1- sous PyQt4, tr et trUtf8 ne transmettent pas les traductions par héritage, du fait d'une différence entre C++ et Python.
2- dans le futur, le maintien de tr et trUtf8 n'est pas garanti. La méthode recommandée est plutôt: QtGui.QApplication.translate.

L'inconvénient de la méthode recommandée étant que les lignes de codes définissant les textes à traduire sont alors interminables...

Voilà la solution proposée:

On a un module Python appelé, par exemple "libtraduc.py" et qui contient une nouvelle définition de tr et trUtf8:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#!/usr/bin/python
# -*- coding: utf-8 -*-
from __future__ import division, print_function
# Python 2.7
 
from PyQt4 import QtCore, QtGui
 
# pour envelopper les chaines à traduire par tr() et trUtf8()
 
#############################################################################
class Traduc(QtCore.QObject):
    def __init__(self): QtCore.QObject.__init__(self)
    def __call__(self, texte, disambig=None, n=-1):
        return QtGui.QApplication.translate("@default", texte, disambig, 
                                            QtGui.QApplication.CodecForTr, n)
tr = Traduc()
 
#############################################################################
class TraducUtf8(QtCore.QObject):
    def __init__(self): QtCore.QObject.__init__(self)
    def __call__(self, texte, disambig=None, n=-1):
        return QtGui.QApplication.translate("@default", texte, disambig, 
                                            QtGui.QApplication.UnicodeUTF8, n)
trUtf8 = TraducUtf8()

Dans un projet PyQt4 composé de plusieurs modules à traduire, tous ces modules, y compris le programme principal, importent ce module comme suit:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

from libtraduc import tr, trUtf8

Et dans tous ces modules Python, on peut utiliser ces 2 fonctions (qui sont en fait toujours des méthodes ayant QObject comme ancêtre) pour définir toutes les chaines à traduire.

Particularité: on n'a plus dans les classes de "self.tr" ni "self.trUtf8" mais seulement "tr" et "trUtf8". De ce fait, les chaines à traduire ne se distinguent plus par le contexte (nom de la classe) parce que le contexte est le même pour le projet: "@default". En contrepartie, s'il faut distinguer 2 chaines identiques qui se traduisent différemment, on utilise le "Disambiguation". Par exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
print(tr("Salut", "1")) # qui doit être traduit par "Hello"
print(tr("Salut", "2")) # qui doit être traduit par "Bye"

Il n'y a plus de différence maintenant entre la définition d'un texte à traduire dans une classe ou en dehors d'une classe.

En faisant comme ça, on a une solution:
- aussi simple qu'avant
- qui transmet les traductions par héritage
- plus pérenne parce qu'elle utilise la méthode recommandée pour PyQt

Voilà un petit exemple qui importe le module libtraduc décrit ci-dessus:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
#!/usr/bin/python
# -*- coding: utf-8 -*-
from __future__ import division, print_function
# Python 2.7
 
import sys, os
from PyQt4 import QtCore, QtGui
 
from libtraduc import tr, trUtf8
 
#############################################################################
# pour installer la langue sélectionnée
# doit rester dans le module principal (celui qui lance l'application))
def changelangue(langue):
    global app, translator_qt, translator
 
    # traduction des messages Qt
    try: app.removeTranslator(translator_qt)
    except: pass    
    translator_qt = QtCore.QTranslator()
    if translator_qt.load(QtCore.QString("qt_") + langue, 
           QtCore.QLibraryInfo.location(QtCore.QLibraryInfo.TranslationsPath)):
        app.installTranslator(translator_qt)
 
    # traduction des textes
    try: app.removeTranslator(translator)
    except: pass    
    nomfichier = os.path.splitext(os.path.basename(sys.argv[0]))[0]
    translator = QtCore.QTranslator()
    if translator.load(nomfichier + u"_" + langue):
        app.installTranslator(translator)
 
#############################################################################
class MaclasseA(QtCore.QObject):
 
    def __init__(self):
        QtCore.QObject.__init__(self)
 
    def hello1(self):
        return trUtf8(u"Salut", "1") # => "Hello"
 
    def hello2(self):
        return trUtf8(u"Salut", "2") # => "Bye"
 
#############################################################################
if __name__ == "__main__":
 
    app = QtGui.QApplication(sys.argv)
    changelangue(QtCore.QLocale.system().name()) # langue = celle de l'OS
 
    reponse = QtGui.QMessageBox.question(None, 
                u"Sélection de la langue",
                u"Voulez-vous le français (anglais sinon)?", 
                QtGui.QMessageBox.Yes, QtGui.QMessageBox.No)
 
    if reponse == QtGui.QMessageBox.Yes:
        changelangue(u"fr_FR")
    else:
        changelangue(u"en_EN")
 
    a = MaclasseA()
 
    print(a.hello1())
    print(a.hello2())
 
    x = trUtf8(u"n'importe quoi") # => anything
    print(x)

Après, il faut, bien sûr utiliser pylupdate4 pour détecter les lignes comportant des chaines à traduire (=> fichier_en_EN.ts), et linguist pour définir les traductions (=> fichier_en_EN.qm), ce dernier fichier étant installé par app.installTranslator.

Lors de l'exécution, il est demandé la langue souhaitée (français ou anglais), et en fonction de la réponse, il s'affiche:

pour le français:

Salut
Salut
n'importe quoi

et pour l'anglais:

Hello
Bye
anything

On voit bien que l'argument "Disambiguation" a bien permis de distinguer 2 mots identiques en français qui devaient avoir une traduction différente.

Ok?

[hizoka]

Dans un projet PyQt4 composé de plusieurs modules à traduire, tous ces modules, y compris le programme principal, importent ce module comme suit:

En effet, s'il n'y a que ça à faire c'est plus pratique

Par contre quelques remarquent :
- Il faudrait laisser la possibilité d'indiquer le contexte du projet (@defaut) car en fonction de l'utilisation voulue ça peut servir dans le rangement des textes pour qtlinguist.

- Est-ce une bonne idée de remplacer les commandes tr et trUtf8 ?
Ne vaudrait-il pas mieux de créer d'autres noms ?

- Y a-t-il un intérêt à conserver tr et trUtf8 ? N'est pas plus simple de n'utiliser que le second ?

Sinon l'idée générale est sympa

Je teste des que j'ai un peu de temps.

[tyrtamos]

Suite et fin: ce que sont les "phrasebooks", et comment s'en servir.

Rappel: après traitement d'un code Python à traduire du français à anglais par pylupdate4, on se retrouve avec un fichier de type XML et d'extension .ts qui contient quelque chose comme:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE TS><TS version="2.0" language="en" sourcelanguage="fr">
<context>
    <name>@default</name>
...
    <message>
        <location filename="test01.py" line="51"/>
        <source>Bonjour</source>
        <translation>Hello</translation>
    </message>
...
</context>
</TS>

On voit que ce fichier .ts est spécifique au fichier Python à traiter (ici "test01.py"), et comporte même les numéros de lignes (line="51").

Mais il y a souvent des termes qu'on rencontre dans la plupart des programmes, tels que: Fichier=>File, Outils=>Tools, Aide=>Help, etc... Et ce serait une perte de temps de vouloir tous les retraduire à chaque nouveau programme.

Alors, il y a les "phrasebooks"! Ce sont des sortes de dictionnaires pré-établis portant les textes courants avec leur traduction. Ce sont des fichiers de type XML comme les fichiers .ts, mais ils portent une extension ".qph". Voilà un exemple de contenu:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
<!DOCTYPE QPH>
<QPH language="en" sourcelanguage="fr">
<phrase>
    <source>Outils</source>
    <target>Tools</target>
</phrase>
<phrase>
    <source>Fichier</source>
    <target>File</target>
</phrase>
</QPH>

On voit que cette fois-ci, il n'y a aucune référence ni au fichier Python traité, ni à des numéros de lignes.

Comment on les fabrique? Avec linguist. Menu "phrases => New phrase book...". Il est demandé de donner un nom au nouveau fichier .qph, et il est créé un fichier .qph vide. Toujours avec le menu "Phrase", on ouvre le fichier, puis on l'édite.

Il vient ensuite une fenêtre permettant de définir chaque texte avec sa traduction. A la fin on enregistre avec "save" et on termine avec "close".

Une fois créé, on peut, bien entendu, reprendre ce fichier et le modifier autant de fois qu'on veut pour l'adapter au type de projets qu'on a.

Comment on s'en sert? Le plus simple quand on est sur un projet est de s'en servir pour traduire les mots courants d'un fichier .ts!

Pour cela, on ouvre le fichier .ts en question dans linguist, et on appelle l'item du menu: "Edit=>Batch translation". Il vient une petite fenêtre dans laquelle on demande que tous les textes du fichier .ts qui n'ont pas encore de traduction mais qui sont dans le fichier .qph, reçoive cette traduction. Et on n'a plus alors qu'à terminer le fichier .ts pour lui ajouter les traductions spécifiques au projet. Attention tout de même: la recherche est sensible à la casse (Fichier et fichier sont 2 mots différents), mais rien ne vous empêche de mettre plusieurs versions (Fichier=File et fichier=>file).

On peut ainsi se constituer progressivement un fichier .qph de phrasebooks dans une traduction donnée permettant de gagner du temps, tout en forçant à une certaine cohérence des mots d'un programme à l'autre.

Par exemple, avec le Qt4 SDK v4.8 sont livrés une quizaine de fichiers .qph pour différentes traductions: "anglais=>autre_langue" (sous Windows, c'est là: C:\QtSDK\QtSources\4.8.0\tools\linguist\phrasebooks). Celui qui concerne la traduction anglais=>français ("french.qph") possède près de 1500 mots courants déjà traduits. Exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<!DOCTYPE QPH>
<QPH language="fr">
<phrase>
    <source>About</source>
    <target>A propos</target>
</phrase>
...
<phrase>
    <source>Apply</source>
    <target>Appliquer</target>
</phrase>
...
<phrase>
    <source>cascading menu</source>
    <target>menu en cascade</target>
</phrase>
...
</QPH>

A noter que pour des programmes simples, on pourrait se contenter de ces dictionnaires simples .qph au lieu des fichiers .ts: c'est possible! Il suffit d'ouvrir le fichier .qph dans linguist comme un fichier .ts, de le compléter si nécessaire, et de le sauvegarder comme un fichier .qm (menu: "Release As") qui sera installé par le programme.

Et voilà pour les phrasebooks! Le reste dans le tuto à venir...

[tyrtamos]

Il faudrait laisser la possibilité d'indiquer le contexte du projet (@defaut) car en fonction de l'utilisation voulue ça peut servir dans le rangement des textes pour qtlinguist.

C'est possible. Par exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
class TraducUtf8(QtCore.QObject):
    def __init__(self, contexte="@default"): 
        QtCore.QObject.__init__(self)
        self.contexte = contexte
    def __call__(self, texte, disambig=None, n=-1):
        return QtGui.QApplication.translate(self.contexte, texte, disambig, 
                                            QtGui.QApplication.UnicodeUTF8, n)
trUtf8 = TraducUtf8()

Ainsi, n'importe où dans le programme, un simple trUtf8.contexte = "moncontexte" affecteront le contexte "moncontexte" à toutes les traductions suivantes.

On pourrait aussi utiliser le disambig comme contexte. Quitte à faire un test pour remettre "@default" à chaque fois que disembig=None.

Est-ce une bonne idée de remplacer les commandes tr et trUtf8 ? Ne vaudrait-il pas mieux de créer d'autres noms ?

On n'a pas le choix à cause de pylupdate4: il ne fait qu'une analyse de texte! Il cherche "tr", "trUtf8" ou "translate". Et si c'est translate et qu'il ne trouve pas en clair unicodeUTF8: c'est mal encodé. Et la chaine de caractère doit être une constante: si c'est une variable, ça ne marche pas. Bref, c'est pratique, mais un peu limité tout de même...

Y a-t-il un intérêt à conserver tr et trUtf8 ? N'est pas plus simple de n'utiliser que le second ?

Pour moi, oui: mes sources Python sont toutes en utf-8, et sont d'abord en français: seule la version utf-8 m'intéresse. Mais celui qui code en latin1 aura besoin de tr.

[edit]: non, la modif proposée pour le contexte ne marche pas, toujours pour la même raison: pylupdate ne fait qu'une analyse de texte. Il trouve le contexte dans 2 cas:

- avec les self.tr ou self.trUtf8, le contexte est pris automatiquement pour le nom de la classe (je ne sais pas comment)

- avec translate, le contexte apparait en clair (=1er argument).

Bref, pour l'instant, je n'ai pas de solution pour ce point, sauf automatiser un remplacement du mot "@default" par un autre mot dans les fichiers .ts.

[hizoka]

Il va falloir que je regarde plus en detail les phrasebooks mais ça m'a l'ai pratique .

Et si on fait simplement ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
class Traduc(QtCore.QObject):
    def __init__(self): QtCore.QObject.__init__(self)
    def __call__(self, texte, contexte="@default", disambig=None, n=-1):
        return QtGui.QApplication.translate(contexte, texte, disambig, 
                                            QtGui.QApplication.CodecForTr, n)

Ca ne marcherait pas car c'est une variable ?
Apres c'est juste du bonus...


Je n'avais pas penser à la recherche des textes à traduire.

Donc en effet tr() est bien.


En tout cas c'est cool qu'on pousse à fond les infos sur la traduction

[hizoka]

Quelques retours sur les phrases book.

Alors c'est en effet très pratique et rapide qui permet d’éviter le travail en double.

Une fois le dictionnaire ouvert dans linguist, il le ré ouvre automatiquement à chaque lancement du logiciel.

Un autre point intéressant, si je veux traduire cut qui est inconnu (il connait Cut), la fenêtre phrases et books me propose une traduction (il m'indique qu'il existe Cut dans le dictionnaire avec sa traduction Couper), si on clique dessus, ça utilise la traduction proposée.


Il est également possible de retraduire les traductions via le Edit=>Batch translation en cochant la dernière option.

[hizoka]

Un autre truc sympa.

Si un dictionnaire est ouvert, que vous traduisez quelque chose par vous même alors que le dictionnaire contient une traduction pour ce terme, un warning apparait pour le signaler.

[hizoka]

J'ai encore fait une découverte pratique :p

Il arrive qu'on ait des textes qui seront affichés que ce soit pour du singulier ou du pluriel, ex :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

J'ai X pomme(s)

Cela donnera donc :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
J'ai 0 pomme(s)
J'ai 1 pomme(s)
J'ai 2 pomme(s)

Pas très élégant... tr propose un truc sympa :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

tr("J'ai %n pomme(s)", "", valeur)

Dans le fichier ts et QtLinguist, la traduction de la chaîne propose :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
Traduction singulier : J'ai %n pomme
Traduction pluriel : J'ai %n pommes

Ainsi en fonction de la valeur, la traduction utilisée sera la bonne.

Très intéressant de voir que certaines langues comme le polonais, il y a de multiples possibilités en fonction des nombres (ça doit être un beau bordel :p)

Par contre, il faudra 2 fichiers de traductions, 1 en français et 1 en anglais par ex.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
Code du fichier python :
tr("J'ai %n pomme(s)", "", valeur)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
Français :
Traduction singulier : J'ai %n pomme
Traduction pluriel : J'ai %n pommes

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
Anglais :
Traduction singulier : I have %n apple
Traduction pluriel : J'ai %n apples

S'il n'y a pas 2 fichiers, cela veut dire qu'il y aura le texte de base (avec le s entre () ) et la traduction adaptée.

http://doc.qt.digia.com/qq/qq19-plurals.html

[tyrtamos]

Bonjour,

Je ne réponds pas parce que je suis sur un autre projet plus impératif, mais je suis avec beaucoup d'intérêt tes découvertes: continue!!! Pour quelqu'un qui démarre, tu avances vraiment très vite!

J'ai commencé mon tuto "internationalisation", mais il est plus long et complexe que je le pensais: il prendra un peu plus de temps (http://python.jpvweb.com/mesrecettes...t4_multilingue).

[pierre++]

Bonjour,

je cherche un moyen de générer un "phrases book" à partir d'un ts déjà traduit, car il est très fastidieux d'enregistrer phrase après phrase.
Si quelqu'un connait une astuce, un programme ou autre ça serait super.

Merci d'avance

[tyrtamos]

Bonjour,

J'ai une solution.

Comme les 2 fichiers .ts et .qph sont des fichiers texte, on peut assez facilement assurer la conversion.

Exemple de fichier .ts:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE TS><TS version="2.0" language="en" sourcelanguage="fr">
<context>
    <name>@default</name>
    <message>
        <location filename="test01.py" line="51"/>
        <source>Bonjour</source>
        <translation>Hello</translation>
    </message>
    <message>
        <location filename="test01.py" line="54"/>
        <source>Fichier</source>
        <translation>File</translation>
    </message>
    <message>
        <location filename="test01.py" line="57"/>
        <source>Outils</source>
        <translation>Tools</translation>
    </message>
</context>
</TS>

Et exemple de fichier .qph (qui sera donc notre cible):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<!DOCTYPE QPH>
<QPH language="fr">
<phrase>
    <source>Bonjour</source>
    <target>Hello</target>
</phrase>
<phrase>
    <source>Fichier</source>
    <target>File</target>
</phrase>
<phrase>
    <source>Outils</source>
    <target>Tools</target>
</phrase>
</QPH>

Pour extraire les mots à traduire du fichier .ts, le plus simple est d'utiliser beautifulsoup (http://www.crummy.com/software/BeautifulSoup/). Une fois installé, voilà comment on fait:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# encodage des fichiers de traduction
encodage = 'utf-8'
 
# lecture du fichier .ts
nfts = "test01_en_EN.ts"
with codecs.open(nfts, 'r', encodage) as f:
    soup = BeautifulSoup(f)
 
# extraction de la liste des traductions
liste = []
for ligne1, ligne2 in zip(soup.find_all('source'), soup.find_all('translation')):
    mot1 = ligne1.get_text()
    mot2 = ligne2.get_text()
    liste.append([mot1, mot2])
print liste

Ce qui donne pour liste:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

[[u'Bonjour', u'Hello'], [u'Fichier', u'File'], [u'Outils', u'Tools']]

Maintenant, il faut construire le fichier .qph avec la liste des mots à traduire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
entete = """<!DOCTYPE QPH>
<QPH language="fr">
"""
basdepage = """</QPH>
"""
debphrase = """<phrase>
"""
finphrase = """</phrase>
""" 
debsource = "    <source>"
finsource = """</source>
"""
debtarget = "    <target>"
fintarget = """</target>
"""
 
texte = entete 
for mot1, mot2 in liste:
    texte += debphrase
    texte += debsource + mot1 + finsource
    texte += debtarget + mot2 + fintarget
    texte += finphrase 
texte += basdepage
 
# enregistrement du texte
nfq = "test01_en_EN.qph"
with codecs.open(nfq, 'w', encodage) as f:
    f.write(texte)

Cela donne un fichier .qph conforme à notre cible. Ce fichier peut être utilisé comme n'importe quel fichier phrasebooks.

Voilà le code en entier (Python 2.7, BeautifulSoup 4.3.2):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
#!/usr/bin/python
# -*- coding: utf-8 -*-
# Python 2.7
 
import codecs
from bs4 import BeautifulSoup
 
#############################################################################
# extraction des mots à traduire du fichier .ts
 
# encodage des fichiers de traduction
encodage = 'utf-8'
 
# lecture du fichier .ts
nfts = "test01_en_EN.ts"
with codecs.open(nfts, 'r', encodage) as f:
    soup = BeautifulSoup(f)
 
# extraction de la liste des traductions
liste = []
for ligne1, ligne2 in zip(soup.find_all('source'), soup.find_all('translation')):
    mot1 = ligne1.get_text()
    mot2 = ligne2.get_text()
    liste.append([mot1, mot2])
 
# affichage de la liste des mots
print liste    
 
#############################################################################
# création du fichier .qph
 
entete = """<!DOCTYPE QPH>
<QPH language="fr">
"""
basdepage = """</QPH>
"""
debphrase = """<phrase>
"""
finphrase = """</phrase>
""" 
debsource = "    <source>"
finsource = """</source>
"""
debtarget = "    <target>"
fintarget = """</target>
"""
 
# intégration des mots à traduire
texte = entete 
for mot1, mot2 in liste:
    texte += debphrase
    texte += debsource + mot1 + finsource
    texte += debtarget + mot2 + fintarget
    texte += finphrase 
texte += basdepage
 
# enregistrement du texte
nfqph = "test01_en_EN.qph"
with codecs.open(nfqph, 'w', encodage) as f:
    f.write(texte)

On pourrait sophistiquer le code en commençant par découvrir l'encodage du fichier .ts, mais je pense que 'utf-8' est une bonne solution générale.

[pierre++]

Bonjour tyrtamos,

merci pour ton aide, il reste un problème de tags html inclus dans les textes à traduire et que le phrase book converti en littéral (< tag &gt.
J'étudie donc comment marche beautifullsoup pour faire la modif.
je pense qu'il suffit juste de rajouter une boucle sur mot1 et mot2 pour faire le remplacement des < > et ça devrait rouler

[hizoka]

Bonsoir, je relance un peu cette discussion.

J'avais indiqué que pour le mode pluriel, il fallait faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

tr("J'ai %n pomme(s)", "", valeur)

au final on peut également faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
x = len(var)
QCoreApplication.translate("main", "Text of %n file(s)", None, x)

mais si je fais :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

QCoreApplication.translate("main", "Text of %n file(s)", None, len(var))

ça ne fonctionne pas, lorsque je lance pylupdate5 ca bloque (sans message).

[tyrtamos]

Bonjour hizoka,

Désolé mais je n'ai rien fait sur le sujet depuis mes interventions dans ce fil, et j'ai bien peur d'être devenu incompétent...

Il me faudrait plusieurs jours pour me remettre à niveau, et je ne les ai pas pour l'instant.

[hizoka]

Aucun problème, je ne faisais que mettre à jour les infos sur la tard car au final tout fonctionne très bien si on passe par une variable temporaire. En espérant que ça serve à d'autres.

[hizoka]

Salut,

hé hé hé, vu que je suis tordu, j'ai trouvé un truc que j'arrive pas à traduire en indiquant les versions singulier/pluriel (oui je sais que l’intérêt est assez limité... mais si ça va lentement... ).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

self.ProgressBar.setFormat(QCoreApplication.translate("main", "%v files done"))

[hizoka]

Je continue avec mon système de traduction :p

il est possible de n'extraire que les chaînes plurielles avec des commandes du style:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

/usr/lib/x86_64-linux-gnu/qt5/bin/lupdate -pluralonly -extensions *.py -ts FICHIER.ts

ou

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

lupdate -qt="qt5-x86_64-linux-gnu" FICHIER.py -pluralonly -ts FICHIER.ts

Utile pour la langue du soft (si le soft est en anglais, on va n'extraire que les pluriels et idem pour le français) pour éviter d'avoir de gros fichiers ts.


Je m'éloigne un peu du sujet mais il est possible de créer des fichiers po de traduction des fichiers man (manuel linux) avec po4a, exemple d'utilisation avec ubuntu.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
sudo apt-get install po4a # installation du soft
po4a-gettextize -f man -m man/qtesseract5.1 -p qtesseract5.fr.po # creation du fichier po à traduire en fr
po4a-translate -f man -m man/qtesseract5.1 -p qtesseract5.fr.po -l fr.man # création de la nouvelle version du fichier man en français