Logging incorrect translations in Django

Question

I often run into the mistake of using gettext in a context where the actual language is not set yet - instead of using the appropriate gettext_lazy.

Those errors can be difficult to catch - I would like to make them more visible appropriate logging, or possibly even throwing exceptions.

• Would it be correct, to write a wrapper function that logs an error in the case of get_language() is None?
• Then of course, one would need to enforce that this wrapper is always used - introducing another subtle easy to make mistake. In general, I suppose monkey-patching could be used, but I'd like to avoid that if possible. The whole dispatch behind django.util.translation seems already relatively complex. Is there a clean way too hook this functionality in there?

Answer 1

You can use Django's built-in checks for this. Django provides a check_for_language function that raises a LanguageStoreNotAvailable exception if the language is not set. You can use this function in your code to check for the availability of the language before calling gettext or gettext_lazy.

from django.utils.translation import check_for_language, gettext

def my_function():
    check_for_language()
    return gettext('Hello, world!')

If the language is not set, this will raise a LanguageStoreNotAvailable exception.

Alternatively, you can use Django's gettext_lazy function, which returns a TranslatableString object that will be translated when it is rendered in a template or when force_text is called on it. This avoids the need to call gettext at all and ensures that the translation is not performed until the language is set.

from django.utils.translation import gettext_lazy

def my_function():
    return gettext_lazy('Hello, world!')

This will return a TranslatableString object that can be used in your code or templates, and the translation will be performed when it is rendered.

Overall, it's generally best to use gettext_lazy whenever possible to avoid the need to explicitly check for the availability of the language. This helps to avoid subtle errors and makes your code more robust.