23.1. gettext — Services d’internationalisation multilingue

Code source : Lib/gettext.py

Le module gettext fournit un service d’internationalisation (I18N) et de localisation linguistique (L10N) pour vos modules et applications Python. Il est compatible avec l’API du catalogue de messages GNU gettext et à un plus haut niveau, avec l’API basée sur les classes qui serait peut-être plus adaptée aux fichiers Python. L’interface décrite ci-dessous vous permet d’écrire les textes de vos modules et applications dans une langue naturelle, puis de fournir un catalogue de traductions pour les lancer ensuite dans d’autres langues naturelles.

Quelques astuces sur la localisation de vos modules et applications Python sont également données.

23.1.1. API GNU gettext

Le module gettext définit l’API suivante, qui est très proche de l’API de GNU gettext. Si vous utilisez cette API, cela affectera la traduction de toute votre application. C’est souvent le comportement attendu si votre application est monolingue, avec le choix de la langue qui dépend des paramètres linguistiques de l’utilisateur. Si vous localisez un module Python ou si votre application a besoin de changer de langue à la volée, il est plus judicieux d’utiliser l’API basée sur des classes.

gettext.bindtextdomain(domain, localedir=None)

Lie domain au répertoire localedir des localisations. Plus spécifiquement, gettext va chercher les fichiers binaires .mo pour un domaine donné, en utilisant le chemin suivant (sous Unix) : localedir/language/LC_MESSAGES/domain.mo, où language est contenu respectivement dans l’une des variables d’environnement suivantes : LANGUAGE, LC_ALL, LC_MESSAGES et LANG.

Si localedir n’est pas renseigné ou vaut None, alors le lien actuel de domain est renvoyé. 1

gettext.bind_textdomain_codeset(domain, codeset=None)

Lie domain à codeset, en changeant l’encodage des chaînes d’octets retournées par les fonctions lgettext(), ldgettext(), lngettext() et ldngettext(). Si codeset n’est pas renseigné, alors le lien actuel est renvoyé.

gettext.textdomain(domain=None)

Change ou interroge le domaine global actuel. Si domain vaut None, alors le domaine global actuel est renvoyé. Sinon, le domaine global est positionné à domain, puis renvoyé.

gettext.gettext(message)

Renvoie la traduction localisée de message, en se basant sur le domaine global actuel, la langue et le répertoire des localisations. Cette fonction est typiquement renommée _() dans le namespace courant (voir les exemples ci-dessous).

gettext.dgettext(domain, message)

Comme gettext(), mais cherche le message dans le domaine spécifié.

gettext.ngettext(singular, plural, n)

Comme gettext(), mais prend en compte les formes au pluriel. Si une traduction a été trouvée, utilise la formule pour trouver le pluriel à n et renvoie le message généré (quelques langues ont plus de deux formes au pluriel). Si aucune traduction n’a été trouvée, renvoie singular si n vaut 1, plural sinon.

La formule pour trouver le pluriel est récupérée dans l’entête du catalogue. C’est une expression en C ou en Python qui a une variable libre n et qui évalue l’index du pluriel dans le catalogue. Voir la documentation de GNU gettext pour la syntaxe précise à utiliser dans les fichiers .po et pour les formules dans différents langues.

gettext.dngettext(domain, singular, plural, n)

Comme ngettext(), mais cherche le message dans le domaine spécifié.

gettext.lgettext(message)
gettext.ldgettext(domain, message)
gettext.lngettext(singular, plural, n)
gettext.ldngettext(domain, singular, plural, n)

Équivalent aux fonctions correspondantes non préfixées par l (gettext(), dgettext(), ngettext() et dngettext()), mais la traduction est retournée en tant que chaîne d’octets, encodée avec l’encodage du système si aucun autre n’a été explicitement défini avec bind_textdomain_codeset().

Avertissement

Ces fonctions sont à éviter en Python 3 car elles renvoient des octets encodés. Il est préférable d’utiliser des alternatives qui renvoient de l’Unicode, puisque beaucoup d’applications Python voudront manipuler du texte lisible par des humains plutôt que des octets. En outre, il est possible que vous obteniez des exceptions non prévues liées à Unicode s’il y a des soucis d’encodage avec les chaînes de caractères traduites. Il est d’ailleurs probable que les fonctions l*() deviennent obsolètes dans les versions futures de Python à cause de leurs problèmes et limitations inhérents.

Notez que GNU gettext a aussi une méthode dcgettext(), mais elle a été considérée comme inutile et donc actuellement marquée comme non implémentée.

Voici un exemple classique d’utilisation de cette API :

import gettext
gettext.bindtextdomain('myapplication', '/path/to/my/language/directory')
gettext.textdomain('myapplication')
_ = gettext.gettext
# ...
print(_('This is a translatable string.'))

23.1.2. API basée sur les classes

L’API du module gettext basée sur les classes vous donne plus de flexibilité et est plus pratique que l’API de GNU gettext. Son utilisation est recommandée pour localiser vos applications et modules Python. gettext définit une classe « translations » qui analyse syntaxiquement les fichiers au format GNU .mo, et qui possède des méthodes pour renvoyer des chaînes de caractères. Les instances de cette classe « translations » peuvent également s’installer dans l’espace de noms natif en tant que fonction _().

gettext.find(domain, localedir=None, languages=None, all=False)

Cette fonction implémente l’algorithme standard de recherche de fichier mo. Il prend en entrée un domain, tout comme la fonction textdomain(). Le paramètre optionnel localedir est le même que celui de bindtextdomain(). Le paramètre optionnel langages est une liste de chaînes de caractères correspondants au code d’une langue.

Si localedir n’est pas renseigné, alors le répertoire de la locale par défaut du système est utilisé. 2 Si languages n’est pas renseigné, alors les variables d’environnement suivantes sont utilisées : LANGUAGE, LC_ALL, LC_MESSAGES et LANG. La première à renvoyer une valeur non vide est alors utilisée pour languages. Ces variables d’environnement doivent contenir une liste de langues, séparées par des deux-points, qui sera utilisée pour générer la liste des codes de langues attendue.

Recherche avec find(), découvre et normalise les langues, puis itère sur la liste obtenue afin de trouver un fichier de traduction existant et correspondant :

localedir/language/LC_MESSAGES/domain.mo

Le premier nom de fichier trouvé est renvoyé par find(). Si aucun fichier n’a été trouvé, alors None est renvoyé. Si all est vrai, est renvoyée la liste de tous les noms de fichiers, dans l’ordre dans lequel ils apparaissent dans languages ou dans les variables d’environnement.

gettext.translation(domain, localedir=None, languages=None, class_=None, fallback=False, codeset=None)

Renvoie une instance de la classe Translations en se basant sur domain, localedir et languages, qui sont d’abord passés en argument de find() afin d’obtenir une liste de chemin des fichiers .mo associés. Les instances avec des noms de fichiers .mo identiques sont mises en cache. La classe réellement instanciée est soit class_ si renseigné, soit une classe GNUTranslations. Le constructeur de cette classe doit prendre en argument un seul file object. Si renseigné, codeset modifiera le jeu de caractères utilisé pour encoder les chaînes de caractères traduites, dans les méthodes lgettext() et lngettext().

Si plusieurs fichiers ont été trouvés, les derniers sont utilisés comme substitut des premiers. Pour rendre possible cette substitution, copy.copy() est utilisé pour copier chaque objet traduit depuis le cache ; les vraies données de l’instance étant toujours recopiées dans le cache.

Si aucun fichier .mo n’a été trouvé, soit fallback vaut False (valeur par défaut) et une exception OSError est levée, soit fallback vaut True et une instance NullTranslations est renvoyée.

Modifié dans la version 3.3: Avant, c’était l’exception IOError qui était levée, au lieu de OSError.

gettext.install(domain, localedir=None, codeset=None, names=None)

Positionne la fonction _() dans l’espace de nommage natif de Python, en se basant sur domain, localedir et codeset, qui sont passés en argument de la fonction translation().

Concernant le paramètre names, se référer à la description de la méthode install().

Habituellement, la fonction _() est appliquée aux chaînes de caractères qui doivent être traduites comme suit :

print(_('This string will be translated.'))

Pour plus de confort, il vaut mieux positionner la fonction _() dans l’espace de nommage natif de Python pour la rendre plus accessible dans tous les modules de votre application.

23.1.2.1. La classe NullTranslations

Les classes de traduction implémentent le fait de passer d’une chaîne de caractères du fichier original à traduire à la traduction de celle-ci. La classe de base utilisée est NullTranslations. C’est l’interface de base à utiliser lorsque vous souhaitez écrire vos propres classes spécifiques à la traduction. Voici les méthodes de NullTranslations :

class gettext.NullTranslations(fp=None)

Prend un paramètre optionnel un file object fp, qui est ignoré par la classe de base. Initialise les variables d’instance « protégées » _info et _chardet, définies par des classes dérivées, tout comme _fallback qui est définie au travers de add_fallback(). Puis appelle self._parse(fp) si fp ne vaut pas None.

_parse(fp)

Cette méthode, non exécutée dans la classe de base, prend en paramètre un objet fichier fp et lit les données de ce dernier. Si vous avez un catalogue de messages dont le format n’est pas pris en charge, vous devriez surcharger cette méthode pour analyser votre format.

add_fallback(fallback)

Ajoute fallback comme objet de substitution pour l’objet de traduction courant. Un objet de traduction devrait interroger cet objet de substitution s’il ne peut fournir une traduction pour un message donné.

gettext(message)

Si un objet de substitution a été défini, transmet gettext() à celui-ci. Sinon, renvoie message. Surchargé dans les classes dérivées.

ngettext(singular, plural, n)

Si un objet de substitution a été défini, transmet ngettext() à celui-ci. Sinon, renvoie singular si n vaut 1, plural sinon. Surchargé dans les classes dérivées.

lgettext(message)
lngettext(singular, plural, n)

Équivalent de gettext() et ngettext(), mais la traduction est renvoyée sous la forme d’une chaîne d’octets, encodée avec l’encodage du système si aucun autre n’a été défini avec set_output_charset(). Surchargé dans les classes dérivées.

Avertissement

L’utilisation de ces méthodes doivent être évitée en Python 3. Voir l’avertissement de la fonction lgettext().

info()

Renvoie la variable « protégée » _info.

charset()

Renvoie l’encodage du fichier du catalogue de messages.

output_charset()

Renvoie l’encodage utilisé par lgettext() et lngettext() pour la traduction des messages.

set_output_charset(charset)

Modifie l’encodage utilisé pour la traduction des messages.

install(names=None)

Cette méthode positionne gettext() dans l’espace de nommage natif, en le liant à _.

Si le paramètre names est renseigné, celui-ci doit être une séquence contenant les noms des fonctions que vous souhaitez positionner dans l’espace de nommage natif, en plus de _(). Les noms pris en charge sont 'gettext', 'ngettext', 'lgettext' et 'lngettext'.

Notez que ce n’est là qu’un moyen parmi d’autres, quoique le plus pratique, pour rendre la fonction _() accessible à votre application. Puisque cela affecte toute l’application, et plus particulièrement l’espace de nommage natif, les modules localisés ne devraient jamais y positionner _(). Au lieu de cela, ces derniers doivent plutôt utiliser le code suivant pour rendre _() accessible par leurs modules :

import gettext
t = gettext.translation('mymodule', ...)
_ = t.gettext

Cela met _() dans l’espace de nommage global du module uniquement et donc n’affectera ses appels que dans ce module.

23.1.2.2. La classe GNUTranslations

Le module gettext fournit une classe supplémentaire qui hérite de NullTranslations : GNUTranslations. Cette classe surcharge _parse() pour permettre de lire les fichiers GNU gettext .mo au format petit et gros-boutiste.

GNUTranslations analyse les métadonnées optionnelles du catalogue de traduction. Il est d’usage avec GNU gettext d’utiliser une métadonnée pour traduire la chaîne vide. Cette métadonnée est un ensemble de paires de la forme clef: valeur comme définie par la RFC 822, et doit contenir la clef Project-Id-Version. Si la clef Content-Type est trouvée dans une métadonnée, alors la propriété charset (jeu de caractères) est utilisée pour initialiser la variable d’instance « protégée » _charset, sinon cette dernière est positionnée à None. Si l’encodage du jeu de caractères est spécifié, tous les messages (identifiants et chaînes de caractères) lus depuis le catalogue sont convertis en chaînes Unicode via cet encodage, ou via l’encodage ASCII si non renseigné.

Et puisque les identifiants des messages sont également lus comme des chaînes Unicode, toutes les méthodes *gettext() les considéreront ainsi, et pas comme des chaînes d’octets.

La totalité des paires clef / valeur est insérée dans un dictionnaire et représente la variable d’instance « protégée » _info.

Si le nombre magique du fichier .mo est invalide, le numéro de la version majeure inattendu, ou si d’autres problèmes apparaissent durant la lecture du fichier, instancier une classe GNUTranslations peut lever une exception OSError.

class gettext.GNUTranslations

Les méthodes suivantes, provenant de l’implémentation de la classe de base, ont été surchargée :

gettext(message)

Recherche l’identifiant de message dans le catalogue et renvoie le message de la chaîne de caractères correspondante comme une chaîne Unicode. Si aucun identifiant n’a été trouvé pour message et qu’un substitut a été défini, la recherche est transmise à la méthode gettext() du substitut. Sinon, l’identifiant de message est renvoyé.

ngettext(singular, plural, n)

Effectue une recherche sur les formes plurielles de l’identifiant d’un message. singular est utilisé pour la recherche de l’identifiant dans le catalogue, alors que n permet de savoir quelle forme plurielle utiliser. La chaîne de caractère du message renvoyée est une chaîne Unicode.

Si l’identifiant du message n’est pas trouvé dans le catalogue et qu’un substitut a été spécifié, la requête est transmise à la méthode ngettext() du substitut. Sinon, est renvoyé singular lorsque n vaut 1, plural dans tous les autres cas.

Voici un exemple :

n = len(os.listdir('.'))
cat = GNUTranslations(somefile)
message = cat.ngettext(
    'There is %(num)d file in this directory',
    'There are %(num)d files in this directory',
    n) % {'num': n}
lgettext(message)
lngettext(singular, plural, n)

Équivalent de gettext() et ngettext(), mais la traduction est renvoyée sous la forme d’une chaîne d’octets, encodée avec l’encodage du système si aucun autre n’a été défini avec set_output_charset().

Avertissement

L’utilisation de ces méthodes doivent être évitée en Python 3. Voir l’avertissement de la fonction lgettext().

23.1.2.3. Support du catalogue de message de Solaris

Le système d’exploitation Solaris possède son propre format de fichier binaire .mo, mais pour l’heure, puisqu’on ne peut trouver de documentation sur ce format, il n’est pas géré.

23.1.2.4. Le constructeur Catalog

GNOME utilise une version du module gettext de James Henstridge, mais qui a une API légèrement différente. D’après la documentation, elle s’utilise ainsi :

import gettext
cat = gettext.Catalog(domain, localedir)
_ = cat.gettext
print(_('hello world'))

Pour des raisons de compatibilité avec cet ancien module, la fonction Catalog() est un alias de la fonction translation() décrite ci-dessous.

Une différence entre ce module et celui de Henstridge : les objets de son catalogue étaient accessibles depuis un schéma de l’API, mais cela semblait ne pas être utilisé et donc n’est pas pris en charge.

23.1.3. Internationaliser vos programmes et modules

L’internationalisation (I18N) consiste à permettre à un programme de recevoir des traductions dans plusieurs langues. La localisation (L10N) consiste à adapter un programme à la langue et aux habitudes culturelles locales, une fois celui-ci internationalisé. Afin de fournir du texte multilingue à votre programme Python, les étapes suivantes sont nécessaires :

  1. préparer votre programme ou module en marquant spécifiquement les chaînes à traduire

  2. lancer une suite d’outils sur les fichiers contenant des chaînes à traduire pour générer des catalogues de messages brut

  3. créer les traductions spécifiques à une langue des catalogues de messages

  4. utiliser le module gettext pour que les chaînes de caractères soient bien traduites

Afin de préparer votre code à être traduit (I18N), vous devrez rechercher toutes les chaînes de caractères de vos fichiers. À chaque chaîne de caractères à traduire doit être appliqué le marqueur _('...') — c’est-à-dire en appelant la fonction _(). Par exemple :

filename = 'mylog.txt'
message = _('writing a log message')
fp = open(filename, 'w')
fp.write(message)
fp.close()

Dans cet exemple, la chaîne 'writing a log message' est maquée comme traduite, contrairement aux chaînes 'mylog.txt' et 'w'.

Il existe quelques outils pour extraire les chaînes de caractères destinées à la traduction. Le programme d’origine GNU gettext ne prenait en charge que les codes sources en C ou C++, mais sa version étendue xgettext peut lire du code écrit dans de nombreux langages, dont le Python, afin de trouver les chaînes notées comme traduisibles. Babel est une bibliothèque en Python d’internationalisation, qui inclut un script pybabel permettant d’extraire et de compiler des catalogues de messages. Le programme de François Pinard, nommé xpot, fait de même et est disponible dans son paquet po-utils.

(Python inclut également des versions en Python de ces programmes, pygettext.py et msgfmt.py, que certaines distributions Python installeront pour vous. pygettext.py est similaire à xgettext, mais ne comprend que le code source écrit en Python et ne peut prendre en charge d’autres langages de programmation tels que le C ou C++. pygettext.py possède une interface en ligne de commande similaire à celle de xgettext — pour plus de détails sur son utilisation, exécuter pygettext.py --help. msgfmt.py est compatible avec GNU msgfmt. Avec ces deux programmes, vous ne devriez pas avoir besoin du paquet GNU gettext pour internationaliser vos applications en Python.)

xgettext, pygettext et d’autres outils similaires génèrent des fichiers .po représentant les catalogues de messages. Il s’agit de fichiers structurés et lisibles par un être humain, qui contiennent toutes les chaînes du code source marquées comme traduisible, ainsi que leur traduction à utiliser.

Les copies de ces fichiers .po sont ensuite remises à des êtres humains qui traduisent le contenu pour chaque langue naturelle prise en charge. Pour chacune des langues, ces derniers renvoient la version complétée sous la forme d’un fichier <code-langue>.po qui a été compilé dans un fichier binaire .mo représentant le catalogue lisible par une machine à l’aide du programme msgfmt. Les fichiers .mo sont utilisés par le module gettext pour la traduction lors de l’exécution.

La façon dont vous utilisez le module gettext dans votre code dépend de si vous internationalisez un seul module ou l’ensemble de votre application. Les deux sections suivantes traitent chacune des cas.

23.1.3.1. Localiser votre module

Si vous localisez votre module, veillez à ne pas faire de changements globaux, e.g. dans l’espace de nom natif. Vous ne devriez pas utiliser l’API GNU gettext mais plutôt celle basée sur les classes.

Disons que votre module s’appelle « spam » et que les fichiers .mo de traduction dans les différentes langues naturelles soient dans /usr/share/locale au format GNU gettext. Voici ce que vous pouvez alors mettre en haut de votre module :

import gettext
t = gettext.translation('spam', '/usr/share/locale')
_ = t.gettext

23.1.3.2. Localiser votre application

Si vous localisez votre application, vous pouvez positionner la fonction _() de manière globale dans l’espace de nommage natif, généralement dans le fichier principal de votre application. Cela permettra à tous les fichiers de votre application de n’utiliser que _('...') sans devoir le redéfinir explicitement dans chaque fichier.

Dans ce cas, vous n’aurez à ajouter que le bout de code suivant au fichier principal de votre application :

import gettext
gettext.install('myapplication')

Si vous avez besoin de définir le dossier des localisations, vous pouvez le mettre en argument de la fonction install() :

import gettext
gettext.install('myapplication', '/usr/share/locale')

23.1.3.3. Changer de langue à la volée

Si votre programme a besoin de prendre en charge plusieurs langues en même temps, vous pouvez créer plusieurs instances de traduction, puis basculer entre elles de façon explicite, comme ceci :

import gettext

lang1 = gettext.translation('myapplication', languages=['en'])
lang2 = gettext.translation('myapplication', languages=['fr'])
lang3 = gettext.translation('myapplication', languages=['de'])

# start by using language1
lang1.install()

# ... time goes by, user selects language 2
lang2.install()

# ... more time goes by, user selects language 3
lang3.install()

23.1.3.4. Traductions différées

Dans la plupart des cas, en programmation, les chaînes de caractères sont traduites à l’endroit où on les écrit. Cependant, il peut arriver que vous ayez besoin de traduire une chaîne de caractères un peu plus loin. Un exemple classique est :

animals = ['mollusk',
           'albatross',
           'rat',
           'penguin',
           'python', ]
# ...
for a in animals:
    print(a)

Ici, vous voulez marquer les chaînes de caractères de la liste animals comme étant traduisibles, mais ne les traduire qu’au moment de les afficher.

Voici un moyen de gérer ce cas :

def _(message): return message

animals = [_('mollusk'),
           _('albatross'),
           _('rat'),
           _('penguin'),
           _('python'), ]

del _

# ...
for a in animals:
    print(_(a))

Cela fonctionne car la définition factice de _() renvoie simplement la chaîne de caractères passée en entrée. Et cette définition factice va temporairement outrepasser toute autre définition de _() dans l’espace de nommage natif (jusqu’à l’utilisation de la commande del). Attention toutefois si vous avez déjà une autre définition de _() dans l’espace de nommage local.

À noter qu’à la deuxième utilisation de _(), « a » ne sera pas vue comme traduisible par le programme gettext car ce n’est pas un chaîne au sens propre.

Voici une autre solution :

def N_(message): return message

animals = [N_('mollusk'),
           N_('albatross'),
           N_('rat'),
           N_('penguin'),
           N_('python'), ]

# ...
for a in animals:
    print(_(a))

Dans ce cas, les chaînes à traduire sont identifiées avec la fonction N_(), qui n’entre pas en conflit avec définition de _(). Cependant, il faudra apprendre à votre programme d’extraction de messages à rechercher les chaînes de caractères à traduire parmi celles ayant le marqueur N_(). xgettext, pygettext, pybabel extract et xpot prennent tous en charge cela grâce à l’option en ligne de commande -k. Le choix du nom N_() ici est totalement arbitraire et aurait très bien pu être MarqueurDeTraduction().

23.1.4. Remerciements

Les personnes suivantes ont contribué au code, ont fait des retours, ont participé aux suggestions de conception et aux implémentations précédentes, et ont partagé leur expérience précieuse pour la création de ce module :

  • Peter Funk

  • James Henstridge

  • Juan David Ibáñez Palomar

  • Marc-André Lemburg

  • Martin von Löwis

  • François Pinard

  • Barry Warsaw

  • Gustavo Niemeyer

Notes

1

Le dossier par défaut pour les localisations dépend du système : par exemple, sur RedHat c’est /usr/share/locale, mais sur Solaris c’est /usr/lib/locale. Le module gettext n’essaie pas de prendre en charge ce paramètre système, mais utilise le dossier sys.prefix/share/locale. C’est pour cette raison qu’il est toujours préférable d’appeler bindtextdomain() en donnant explicitement un chemin absolu au début de votre application.

2

Voir la note de bindtextdomain() ci-dessus.