Using gettext in compiled Qt ui files with PyQt

Recently I received an email asking me for a more detailed explanation of the post, what better to add it as a comment so that others can find it. From my email:

The trick here is based on the fact that we are extending the uic compiler to modify the way it generates the python code. The idea is very simple. Lets imaging that you could tell the uic compiler to use gettext rather than the normal Qt translation methods. That way instead of using the Qt method you would call those from gettext. Lets take a look at what I mean:

Qt: tr(‘my translated string’)
gettext: _(‘my translated string’)

As you can see the actual differences between the code are minimum, so this can clearly be done automatically. In PyQt4 and PySide (although I ahve not tested it) you can extend the python compiler class to modify its behaviour the way you want, and that is precisely what the blog pots talks about. Lets take a look step by step at this process:

The first thing we would like to do is to create an extension of the compiler class, that we can do as follows:

from PyQt4.uic.Compiler import compiler, qtproxies, indenter

# pylint: disable=C0103
class _UICompiler(compiler.UICompiler):
“”"Speciallized compiler for qt .ui files.”"”

within this child class we are going to override the method that creates the top level widget, this allows us to add imports to the python code so that we can import the gettext method.

def createToplevelWidget(self, classname, widgetname):
o = indenter.getIndenter()
o.level = 0
o.write(‘from module.with.gettext.setup import _’)
return super(_UICompiler, self).createToplevelWidget(
classname, widgetname)

where ‘from module.with.gettext.setup import _’ represents the module in your python application in which you have done the setup of gettext. Of course you do not have to do that in a diff module, but I like to keep everything in the same place. This compiler class will already provide a compiled .uic code with the extra import, but ofcourse that is not everything. The next step is to tell the compiler to use gettext for the translations. To do that we extend a new class that is sued by the compiler class which is the

qtproxies.i18n_string

which as the name states takes care of the translations:

class _i18n_string(qtproxies.i18n_string):
“”"Provide a translated text.”"”

def __str__(self):
return “_(‘%s’)” % self.string.encode(
‘string-escape’)

There we are using ‘_’ which is the name of the function used by gettext for translations, and what it does is to ensure that all translatable string in you app are translated in such a way.

To ensure that the uic modules uses or extended classes we just have to import:

from PyQt4.uic.Compiler import compiler, qtproxies, indenter

And set the correct classes, one for the compiler:

compiler.UICompiler = _UICompiler

and for the translating class:

qtproxies.i18n_string = _i18n_string

All this in my example is done in a class method which extends all the required classes and sets them up. Once you have all this set you can call the uic compilation from your setup.py, for example:

from PyQt4 import uic
fp = open(py_file, ‘w’)
uic.compileUi(ui_file, fp)
fp.close()

I hope the explanamtion makes more sense. I suppose that you are not the only one that have not understood the example fully so I’ll put this answer in the post comments.

I hope it helps and let me know if you need any other help.