Python i18n API. Many thanks to Campbell and Brecht for the reviews and suggestions!

This commit adds:
* A new bpy.app.translations module giving some info about locales/translation stuff (current active locale, all locales currently known by blender, all translation contexts currently defined, etc.).

* The ability for addons to feature translations, using the (un)register functions of above module.

* Also cleans up "translate py string when storing into RNA prop" by removing "PROP_TRANSLATE" string's subtype, and adding a PROP_STRING_PY_TRANSLATE flag instead (this way it is no more exposed to python...).

Addon translations work with py dictionaries: each addon features a dict {lang: {(context, message): translation, ...}, ...}, which is registered when the addon is enabled (and unregistered when disabled). 

Then, when a key (context, message) is not found in regular mo catalog, a cache dict for current locale is built from all registered addon translations, and key is searched in it.

Note: currently addons writers have to do all the work by hand, will add something (probably extend "edit translation" addon) to automate messages extraction from addons soon(ish)! To get a look to expected behavior from addons, have a look at render_copy_settings/__init__.py and render_copy_settings/translations.py (rather stupid example currently, but...). Once we have a complete process, I'll also update relevant wiki pages.

1 files changed, 638 insertions, 0 deletions

diff --git a/source/blender/python/intern/bpy_app_translations.c b/source/blender/python/intern/bpy_app_translations.c
new file mode 100644
index 00000000000..b501ed2a226
--- /dev/null
+++ b/source/blender/python/intern/bpy_app_translations.c
@@ -0,0 +1,638 @@
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * Contributor(s): Bastien Montagne
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file blender/python/intern/bpy_app_translations.c
+ *  \ingroup pythonintern
+ *
+ * This file defines a singleton py object accessed via 'bpy.app.translations',
+ * which exposes various data and functions useful in i18n work.
+ * Most notably, it allows to extend main translations with py dicts.
+ */
+
+#include <Python.h>
+/* XXX Why bloody hell isn't that included in Python.h???? */
+#include <structmember.h>
+
+/* Need this one before BPY_extern.h, for bool def! */
+#include "BLI_utildefines.h"
+
+#include "BPY_extern.h"
+#include "bpy_app_translations.h"
+
+#ifdef WITH_INTERNATIONAL
+
+#include "MEM_guardedalloc.h"
+
+#include "BLI_string.h"
+#include "BLI_ghash.h"
+
+#include "BLF_translation.h"
+
+#include "RNA_types.h"
+#include "RNA_access.h"
+
+
+typedef struct
+{
+	PyObject_HEAD
+	/* The string used to separate context from actual message in PY_TRANSLATE RNA props. */
+	const char *context_separator;
+	/* A "named tuple" (StructSequence actually...) containing all C-defined contexts. */
+	PyObject *contexts;
+	/* A readonly mapping {C context id: python id}  (actually, a MappingProxy). */
+	PyObject *contexts_C_to_py;
+	/* A py dict containing all registered py dicts (order is more or less random, first match wins!). */
+	PyObject *py_messages;
+} BlenderAppTranslations;
+
+/* Our singleton instance pointer */
+static BlenderAppTranslations *_translations = NULL;
+
+/***** Helpers for ghash *****/
+typedef struct GHashKey {
+	const char *msgctxt;
+	const char *msgid;
+} GHashKey;
+
+static GHashKey *_ghashutil_keyalloc(const void *msgctxt, const void *msgid)
+{
+	GHashKey *key = MEM_mallocN(sizeof(GHashKey), "GHashPair");
+	key->msgctxt = BLI_strdup(msgctxt);
+	key->msgid = BLI_strdup(msgid);
+	return key;
+}
+
+static unsigned int _ghashutil_keyhash(const void *ptr)
+{
+	const GHashKey *key = ptr;
+	unsigned int hash =  BLI_ghashutil_strhash(key->msgctxt);
+	return hash ^ BLI_ghashutil_strhash(key->msgid);
+}
+
+static int _ghashutil_keycmp(const void *a, const void *b)
+{
+	const GHashKey *A = a;
+	const GHashKey *B = b;
+
+	/* Note: comparing msgid first, most of the time it will be enough! */
+	int cmp = BLI_ghashutil_strcmp(A->msgid, B->msgid);
+	if (cmp == 0)
+		return BLI_ghashutil_strcmp(A->msgctxt, B->msgctxt);
+	return cmp;
+}
+
+static void _ghashutil_keyfree(void *ptr)
+{
+	const GHashKey *key = ptr;
+
+	/* We assume both msgctxt and msgid were BLI_strdup'ed! */
+	MEM_freeN((void *)key->msgctxt);
+	MEM_freeN((void *)key->msgid);
+	MEM_freeN((void *)key);
+}
+
+static void _ghashutil_valfree(void *ptr)
+{
+	MEM_freeN(ptr);
+}
+
+/***** Python's messages cache *****/
+
+/* We cache all messages available for a given locale from all py dicts into a single ghash.
+ * Changing of locale is not so common, while looking for a message translation is, so let's try to optimize
+ * the later as much as we can!
+ * Note changing of locale, as well as (un)registering a message dict, invalidate that cache.
+ */
+static GHash *_translations_cache = NULL;
+
+static void _clear_translations_cache(void)
+{
+	if (_translations_cache) {
+		BLI_ghash_free(_translations_cache, _ghashutil_keyfree, _ghashutil_valfree);
+	}
+	_translations_cache = NULL;
+}
+
+static void _build_translations_cache(PyObject *py_messages, const char *locale)
+{
+	PyObject *uuid_dict;
+	Py_ssize_t pos = 0;
+	char *language = NULL, *language_country = NULL, *language_variant = NULL;
+
+	/* For each py dict, we'll search for full locale, then language+country, then language+variant,
+	 * then only language keys... */
+	BLF_locale_explode(locale, &language, NULL, NULL, &language_country, &language_variant);
+
+	/* Clear the cached ghash if needed, and create a new one. */
+	_clear_translations_cache();
+	_translations_cache = BLI_ghash_new(_ghashutil_keyhash, _ghashutil_keycmp, __func__);
+
+	/* Iterate over all py dicts. */
+	while(PyDict_Next(py_messages, &pos, NULL, &uuid_dict)) {
+		PyObject *lang_dict;
+
+#if 0
+		PyObject_Print(uuid_dict, stdout, 0);
+		printf("\n");
+#endif
+
+		if (!PyDict_Check(uuid_dict))
+			continue;
+
+		/* Try to get first complete locale, then language+country, then language+variant, then only language */
+		lang_dict = PyDict_GetItemString(uuid_dict, locale);
+		if (!lang_dict && language_country)
+			lang_dict = PyDict_GetItemString(uuid_dict, language_country);
+		if (!lang_dict && language_variant)
+			lang_dict = PyDict_GetItemString(uuid_dict, language_variant);
+		if (!lang_dict && language)
+			lang_dict = PyDict_GetItemString(uuid_dict, language);
+
+		if (lang_dict && PyDict_Check(lang_dict)) {
+			PyObject *pykey, *trans;
+			Py_ssize_t ppos = 0;
+
+			/* Iterate over all translations of the found language dict, and populate our ghash cache. */
+			while(PyDict_Next(lang_dict, &ppos, &pykey, &trans)) {
+				GHashKey *key;
+				PyObject *tmp;
+				const char *msgctxt = NULL, *msgid = NULL;
+
+				tmp = PyTuple_GetItem(pykey, 0);
+				if (tmp && PyUnicode_Check(tmp) && !PyUnicode_READY(tmp)) {
+					msgctxt = (const char *)PyUnicode_AsUTF8(tmp);
+				}
+				tmp = PyTuple_GetItem(pykey, 1);
+				if (tmp && PyUnicode_Check(tmp) && !PyUnicode_READY(tmp)) {
+					msgid = (const char *)PyUnicode_AsUTF8(tmp);
+				}
+
+				if (!(msgctxt && msgid)) {
+					continue;
+				}
+
+				key = _ghashutil_keyalloc(msgctxt, msgid);
+
+				/* Do not overwrite existing keys! */
+				if (BLI_ghash_lookup(_translations_cache, (void *)key)) {
+					continue;
+				}
+
+				if (trans && PyUnicode_Check(trans) && !PyUnicode_READY(trans)) {
+					BLI_ghash_insert(_translations_cache, key, BLI_strdup((const char *)PyUnicode_AsUTF8(trans)));
+				}
+			}
+		}
+	}
+
+	/* Clean up! */
+	if (language)
+		MEM_freeN(language);
+	if (language_country)
+		MEM_freeN(language_country);
+	if (language_variant)
+		MEM_freeN(language_variant);
+}
+
+const char *BPY_app_translations_py_pgettext(const char *msgctxt, const char *msgid)
+{
+#define STATIC_LOCALE_SIZE 32  /* Should be more than enough! */
+
+	GHashKey *key;
+	static char locale[STATIC_LOCALE_SIZE] = "";
+	const char *tmp;
+
+	/* Just in case, should never happen! */
+	if (!_translations)
+		return msgid;
+
+	tmp = BLF_lang_get();
+	if (strcmp(tmp, locale) || !_translations_cache) {
+		PyGILState_STATE _py_state;
+
+		BLI_strncpy(locale, tmp, STATIC_LOCALE_SIZE);
+
+		/* Locale changed or cache does not exist, refresh the whole cache! */
+		/* This func may be called from C (i.e. outside of python interpreter 'context'). */
+		_py_state = PyGILState_Ensure();
+
+		_build_translations_cache(_translations->py_messages, locale);
+
+		PyGILState_Release(_py_state);
+	}
+
+	/* And now, simply create the key (context, messageid) and find it in the cached dict! */
+	key = _ghashutil_keyalloc(msgctxt ? msgctxt : BLF_I18NCONTEXT_DEFAULT, msgid);
+
+	tmp = BLI_ghash_lookup(_translations_cache, key);
+
+	if (tmp)
+		return tmp;
+	return msgid;
+
+#undef STATIC_LOCALE_SIZE
+}
+
+PyDoc_STRVAR(app_translations_py_messages_register_doc,
+".. method:: register(module_name, translations_dict)\n"
+"\n"
+"   Registers an addon's UI translations.\n"
+"\n"
+"   :arg module_name: The name identifying the addon.\n"
+"   :type module_name: string\n"
+"   :arg translations_dict: A dictionary built like that:\n"
+"       {locale: {msg_key: msg_translation, ...}, ...}\n"
+"   :type translations_dict: dict\n"
+"\n"
+);
+static PyObject *app_translations_py_messages_register(BlenderAppTranslations *self, PyObject *args, PyObject *kw)
+{
+	static const char *kwlist[] = {"module_name", "translations_dict", NULL};
+	PyObject *module_name, *uuid_dict;
+
+	if (!PyArg_ParseTupleAndKeywords(args, kw, "O!O!:bpy.app.translations.register", (char **)kwlist, &PyUnicode_Type,
+	                                 &module_name, &PyDict_Type, &uuid_dict))
+	{
+		return NULL;
+	}
+
+	if (PyDict_Contains(self->py_messages, module_name)) {
+		PyErr_Format(PyExc_ValueError,
+		             "bpy.app.translations.register: translations message cache already contains some data for "
+		             "addon '%s'", (const char *)PyUnicode_1BYTE_DATA(module_name));
+		return NULL;
+	}
+
+	PyDict_SetItem(self->py_messages, module_name, uuid_dict);
+
+	/* Clear cached messages dict! */
+	_clear_translations_cache();
+
+	/* And we are done! */
+	Py_RETURN_NONE;
+}
+
+PyDoc_STRVAR(app_translations_py_messages_unregister_doc,
+".. method:: unregister(module_name)\n"
+"\n"
+"   Unregisters an addon's UI translations.\n"
+"\n"
+"   :arg module_name: The name identifying the addon.\n"
+"   :type module_name: string\n"
+"\n"
+);
+static PyObject *app_translations_py_messages_unregister(BlenderAppTranslations *self, PyObject *args, PyObject *kw)
+{
+	static const char *kwlist[] = {"module_name", NULL};
+	PyObject *module_name;
+
+	if (!PyArg_ParseTupleAndKeywords(args, kw, "O!:bpy.app.translations.unregister", (char **)kwlist, &PyUnicode_Type,
+	                                 &module_name))
+	{
+		return NULL;
+	}
+
+	if (PyDict_Contains(self->py_messages, module_name)) {
+		PyDict_DelItem(self->py_messages, module_name);
+		/* Clear cached messages ghash! */
+		_clear_translations_cache();
+	}
+
+	/* And we are done! */
+	Py_RETURN_NONE;
+}
+
+
+/***** C-defined contexts *****/
+
+static PyTypeObject BlenderAppTranslationsContextsType;
+
+static BLF_i18n_contexts_descriptor _contexts[] = BLF_I18NCONTEXTS_DESC;
+
+/* These fields are just empty placeholders, actual values get set in app_translations_struct().
+ * This allows us to avoid many handwriting, and above all, to keep all context definition stuff in BLF_translation.h!
+ */
+static PyStructSequence_Field
+app_translations_contexts_fields[sizeof(_contexts) / sizeof(BLF_i18n_contexts_descriptor)] = {{NULL}};
+
+static PyStructSequence_Desc app_translations_contexts_desc = {
+	(char *)"bpy.app.translations.contexts",     /* name */
+	(char *)"This named tuple contains all pre-defined translation contexts",    /* doc */
+	app_translations_contexts_fields,    /* fields */
+	(sizeof(app_translations_contexts_fields) / sizeof(PyStructSequence_Field)) - 1
+};
+
+static PyObject *app_translations_contexts_make(void)
+{
+	PyObject *translations_contexts;
+	BLF_i18n_contexts_descriptor *ctxt;
+	int pos = 0;
+
+	translations_contexts = PyStructSequence_New(&BlenderAppTranslationsContextsType);
+	if (translations_contexts == NULL) {
+		return NULL;
+	}
+
+#define SetObjString(item) PyStructSequence_SET_ITEM(translations_contexts, pos++, PyUnicode_FromString((item)))
+
+	for (ctxt = _contexts; ctxt->c_id; ctxt++) {
+		SetObjString(ctxt->value);
+	}
+
+#undef SetObjString
+
+	return translations_contexts;
+}
+
+/***** Main BlenderAppTranslations Py object definition *****/
+
+PyDoc_STRVAR(app_translations_contexts_doc,
+	"A named tuple containing all pre-defined translation contexts."
+);
+
+PyDoc_STRVAR(app_translations_contexts_C_to_py_doc,
+	"A readonly dict mapping contexts' C-identifiers to their py-identifiers."
+);
+
+PyMemberDef app_translations_members[] = {
+	{(char *)"contexts", T_OBJECT_EX, offsetof(BlenderAppTranslations, contexts), READONLY,
+	                     app_translations_contexts_doc},
+	{(char *)"contexts_C_to_py", T_OBJECT_EX, offsetof(BlenderAppTranslations, contexts_C_to_py), READONLY,
+	                             app_translations_contexts_C_to_py_doc},
+	{NULL}
+};
+
+PyDoc_STRVAR(app_translations_locale_doc, "The actual locale currently in use.");
+static PyObject *app_translations_locale_get(PyObject *UNUSED(self), void *UNUSED(userdata))
+{
+	return PyUnicode_FromString(BLF_lang_get());
+}
+
+/* Note: defining as getter, as (even if quite unlikely), this *may* change during runtime... */
+PyDoc_STRVAR(app_translations_locales_doc, "All locales currently known by Blender (i.e. available as translations).");
+static PyObject *app_translations_locales_get(PyObject *UNUSED(self), void *UNUSED(userdata))
+{
+	PyObject *ret;
+	EnumPropertyItem *it, *items = BLF_RNA_lang_enum_properties();
+	int num_locales = 0, pos = 0;
+
+	/* This is not elegant, but simple! */
+	for (it = items; it->identifier; it++) {
+		if (it->value)
+			num_locales++;
+	}
+
+	ret = PyTuple_New(num_locales);
+
+#define TupleSetItem() PyTuple_SET_ITEM(ret, pos++, PyUnicode_FromString(it->description))
+
+	for (it = items; it->identifier; it++) {
+		if (it->value)
+			TupleSetItem();
+	}
+
+#undef TupleSetItem
+
+	return ret;
+}
+
+PyGetSetDef app_translations_getseters[] = {
+	/* {name, getter, setter, doc, userdata} */
+	{(char *)"locale", (getter)app_translations_locale_get, NULL, app_translations_locale_doc, NULL},
+	{(char *)"locales", (getter)app_translations_locales_get, NULL, app_translations_locales_doc, NULL},
+	{NULL}
+};
+
+PyDoc_STRVAR(app_translations_pgettext_doc,
+".. method:: pgettext(msgid, msgctxt)\n"
+"\n"
+"   Try to translate the given msgid (with optional msgctxt).\n"
+"   NOTE: The (msgid, msgctxt) parameter orders has been switched compared to gettext function, to allow\n"
+"         single-parameter calls (context then defaults to BLF_I18NCONTEXT_DEFAULT)."
+"   NOTE: You should really rarely need to use this function in regular addon code, as all translation should be\n"
+"         handled by Blender internal code."
+"\n"
+"   :arg msgid: The string to translate.\n"
+"   :type msgid: string\n"
+"   :arg msgctxt: The translation context.\n"
+"   :type msgctxt: string\n"
+"   :default msgctxt: BLF_I18NCONTEXT_DEFAULT value.\n"
+"   :return: The translated string (or msgid if no translation was found).\n"
+"\n"
+);
+static PyObject *app_translations_pgettext(BlenderAppTranslations *UNUSED(self), PyObject *args, PyObject *kw)
+{
+	static const char *kwlist[] = {"msgid", "msgctxt", NULL};
+	char *msgid, *msgctxt = NULL;
+
+	if (!PyArg_ParseTupleAndKeywords(args, kw, "s|s:bpy.app.translations.pgettext()", (char **)kwlist,
+	                                 &msgid, &msgctxt))
+	{
+		return NULL;
+	}
+
+	return PyUnicode_FromString(BLF_pgettext(msgctxt ? msgctxt : BLF_I18NCONTEXT_DEFAULT, msgid));
+}
+
+PyMethodDef app_translations_methods[] = {
+	/* Can't use METH_KEYWORDS alone, see http://bugs.python.org/issue11587 */
+	{(char *)"register", (PyCFunction)app_translations_py_messages_register, METH_VARARGS | METH_KEYWORDS,
+	                     app_translations_py_messages_register_doc},
+	{(char *)"unregister", (PyCFunction)app_translations_py_messages_unregister, METH_VARARGS | METH_KEYWORDS,
+	                       app_translations_py_messages_unregister_doc},
+	{(char *)"pgettext", (PyCFunction)app_translations_pgettext, METH_VARARGS | METH_KEYWORDS | METH_STATIC,
+	                      app_translations_pgettext_doc},
+	{NULL}
+};
+
+static PyObject *app_translations_new(PyTypeObject *type, PyObject *UNUSED(args), PyObject *UNUSED(kw))
+{
+/*	printf("%s (%p)\n", __func__, _translations); */
+
+	if (!_translations) {
+		_translations = (BlenderAppTranslations *)type->tp_alloc(type, 0);
+		if (_translations) {
+			PyObject *py_ctxts;
+			BLF_i18n_contexts_descriptor *ctxt;
+
+			_translations->contexts = app_translations_contexts_make();
+
+			py_ctxts = PyDict_New();
+			for (ctxt = _contexts; ctxt->c_id; ctxt++) {
+				PyObject *val = PyUnicode_FromString(ctxt->py_id);
+				PyDict_SetItemString(py_ctxts, ctxt->c_id, val);
+				Py_DECREF(val);
+			}
+			_translations->contexts_C_to_py = PyDictProxy_New(py_ctxts);
+			Py_DECREF(py_ctxts);  /* The actual dict is only owned by its proxy */
+
+			_translations->py_messages = PyDict_New();
+		}
+	}
+
+	return (PyObject *)_translations;
+}
+
+PyDoc_STRVAR(app_translations_doc,
+"   This object contains some data/methods regarding internationalization in Blender, and allows every py script\n"
+"   to feature translations for its own UI messages.\n"
+"\n"
+"   WARNING: Most of this object should only be useful if you actually manipulate i18n stuff from Python.\n"
+"            If you are a regular addon, you should only bother about :contexts: and :context_sep: members, and the \n"
+"            :register:/:unregister: functions!"
+"\n"
+"   To add translations to your python script, you must define a dictionary formatted like that:\n"
+"       {locale: {msg_key: msg_translation, ...}, ...}\n"
+"       where:\n"
+"           locale is either a lang iso code (e.g. 'fr'), a lang+country code (e.g. 'pt_BR'),\n"
+"                  a lang+variant code (e.g. 'sr@latin'), or a full code (e.g. 'uz_UZ@cyrilic').\n"
+"           msg_key is a tuple (context, org message) - use, as much as possible, the predefined :contexts:.\n"
+"           msg_translation is the translated message in given language!"
+"   Then, call bpy.app.translations.register(__name__, your_dict) in your register() function, and \n"
+"   bpy.app.translations.unregister(__name__) in your unregister() one.\n"
+"\n"
+"   bl_i18n_utils module has several functions to help you collect strings to translate, and generate the needed\n"
+"   python code (the translation dictionary), as well as optional intermediary po files if you want some...\n"
+"   See its documentation for more details.\n"
+"\n"
+);
+static PyTypeObject BlenderAppTranslationsType = {
+	PyVarObject_HEAD_INIT(NULL, 0)
+	                            /* tp_name */
+	(char *)"bpy.app._translations_type",
+	                            /* tp_basicsize */
+	sizeof(BlenderAppTranslations),
+	0,                          /* tp_itemsize */
+	/* methods */
+	/* No destructor, this is a singleton! */
+	NULL,                       /* tp_dealloc */
+	NULL,                       /* printfunc tp_print; */
+	NULL,                       /* getattrfunc tp_getattr; */
+	NULL,                       /* setattrfunc tp_setattr; */
+	NULL,                       /* tp_compare */ /* DEPRECATED in python 3.0! */
+	NULL,                       /* tp_repr */
+
+	/* Method suites for standard classes */
+	NULL,                       /* PyNumberMethods *tp_as_number; */
+	NULL,                       /* PySequenceMethods *tp_as_sequence; */
+	NULL,                       /* PyMappingMethods *tp_as_mapping; */
+
+	/* More standard operations (here for binary compatibility) */
+	NULL,                       /* hashfunc tp_hash; */
+	NULL,                       /* ternaryfunc tp_call; */
+	NULL,                       /* reprfunc tp_str; */
+	NULL,                       /* getattrofunc tp_getattro; */
+	NULL,                       /* setattrofunc tp_setattro; */
+
+	/* Functions to access object as input/output buffer */
+	NULL,                       /* PyBufferProcs *tp_as_buffer; */
+
+	/*** Flags to define presence of optional/expanded features ***/
+	Py_TPFLAGS_DEFAULT,         /* long tp_flags; */
+
+	app_translations_doc,       /* char *tp_doc;  Documentation string */
+
+	/*** Assigned meaning in release 2.0 ***/
+	/* call function for all accessible objects */
+	NULL,                       /* traverseproc tp_traverse; */
+
+	/* delete references to contained objects */
+	NULL,                       /* inquiry tp_clear; */
+
+	/***  Assigned meaning in release 2.1 ***/
+	/*** rich comparisons ***/
+	NULL,                       /* richcmpfunc tp_richcompare; */
+
+	/***  weak reference enabler ***/
+	0,                          /* long tp_weaklistoffset */
+
+	/*** Added in release 2.2 ***/
+	/*   Iterators */
+	NULL,                       /* getiterfunc tp_iter; */
+	NULL,                       /* iternextfunc tp_iternext; */
+
+	/*** Attribute descriptor and subclassing stuff ***/
+	app_translations_methods,   /* struct PyMethodDef *tp_methods; */
+	app_translations_members,   /* struct PyMemberDef *tp_members; */
+	app_translations_getseters, /* struct PyGetSetDef *tp_getset; */
+	NULL,                       /* struct _typeobject *tp_base; */
+	NULL,                       /* PyObject *tp_dict; */
+	NULL,                       /* descrgetfunc tp_descr_get; */
+	NULL,                       /* descrsetfunc tp_descr_set; */
+	0,                          /* long tp_dictoffset; */
+	NULL,                       /* initproc tp_init; */
+	NULL,                       /* allocfunc tp_alloc; */
+	                            /* newfunc tp_new; */
+	(newfunc)app_translations_new,
+	/*  Low-level free-memory routine */
+	NULL,                       /* freefunc tp_free;  */
+	/* For PyObject_IS_GC */
+	NULL,                       /* inquiry tp_is_gc;  */
+	NULL,                       /* PyObject *tp_bases; */
+	/* method resolution order */
+	NULL,                       /* PyObject *tp_mro;  */
+	NULL,                       /* PyObject *tp_cache; */
+	NULL,                       /* PyObject *tp_subclasses; */
+	NULL,                       /* PyObject *tp_weaklist; */
+	NULL
+};
+
+PyObject *BPY_app_translations_struct(void)
+{
+	PyObject *ret;
+
+	/* Let's finalize our contexts structseq definition! */
+	{
+		BLF_i18n_contexts_descriptor *ctxt;
+		PyStructSequence_Field *desc;
+
+		/* We really populate the contexts' fields here! */
+		for (ctxt = _contexts, desc = app_translations_contexts_desc.fields; ctxt->c_id; ctxt++, desc++) {
+			desc->name = (char *)ctxt->py_id;
+			desc->doc = NULL;
+		}
+		desc->name = desc->doc = NULL;  /* End sentinel! */
+
+		PyStructSequence_InitType(&BlenderAppTranslationsContextsType, &app_translations_contexts_desc);
+	}
+
+	if (PyType_Ready(&BlenderAppTranslationsType) < 0)
+		return NULL;
+
+	ret = PyObject_CallObject((PyObject *)&BlenderAppTranslationsType, NULL);
+
+	/* prevent user from creating new instances */
+	BlenderAppTranslationsType.tp_new = NULL;
+	/* without this we can't do set(sys.modules) [#29635] */
+	BlenderAppTranslationsType.tp_hash = (hashfunc)_Py_HashPointer;
+
+	return ret;
+}
+
+#else  /* WITH_INTERNATIONAL */
+
+PyObject *BPY_app_translations_struct(void)
+{
+	Py_RETURN_NONE;
+}
+
+#endif  /* WITH_INTERNATIONAL */