YJL

1   Django 1.2.5 Template

Anyway, I decided to use Django 1.2.5 Template since it’s shipped with SDK. Amazingly, it’s so easy to switch to another version from the default version 0.96. This is what I only added before the template import, suggested by the doc,

# os.environ['DJANGO_SETTINGS_MODULE'] = 'settings'

from google.appengine.dist import use_library
use_library('django', '1.2')

from google.appengine.ext.webapp import template

I only use template. I don’t know if i18n will be this easy as well, I might do a follow-up later. I need to mention I didn’t want to switch at first and still don’t. But it seems that I have to.

def main():

  webapp.template.register_template_library('django.contrib.humanize.templatetags.humanize')
  run_wsgi_app(application)

2   Capability name of datastore for CapabilitySet

I read the documentation about the supported capabilities and I had these

CapabilitySet('datastore').is_enabled()
CapabilitySet('datastore_write').is_enabled()
CapabilitySet('memcache').is_enabled()

They run fine on development server, however, after I deployed the code, I got:

Traceback (most recent call last):
  File "/base/python_runtime/python_lib/versions/1/google/appengine/ext/webapp/__init__.py", line 515, in __call__
    handler.get(*groups)
  File "/base/data/home/apps/lilbtn/1.348320236448169656/itchape.py", line 205, in get
    if CapabilitySet('datastore').is_enabled():
  File "/base/python_runtime/python_lib/versions/1/google/appengine/api/capabilities/__init__.py", line 98, in is_enabled
    config = self._get_status()
  File "/base/python_runtime/python_lib/versions/1/google/appengine/api/capabilities/__init__.py", line 170, in _get_status
    raise UnknownCapabilityError()
UnknownCapabilityError

The memory cache part is fine. I don’t know why that name of capability didn’t work, but I found an alternates,

db.READ_CAPABILITY
db.WRITE_CAPABILITY

But I use these later,

CapabilitySet('datastore_v3', capabilities=['read']).is_enabled()
CapabilitySet('datastore_v3', capabilities=['write']).is_enabled()

I found the second line on Handling downtime: The capabilities API and testing, which I had skimmed when it was published.

1   Setting Up

We need to use Django Settings to make I18N work. The reason of using Setting was due to Django’s gettext helper will require Settings module and decide location of message files by the location of Settings module.

If we want to use Django Setting, we must run the following code:

from google.appengine.ext.webapp import template

os.environ['DJANGO_SETTINGS_MODULE'] = 'conf.settings'
from django.conf import settings
# Force Django to reload settings
settings._target = None

Note that you must import the google.appengine.ext.webapp.template module, or you might get error about conf.settings is not able to be imported.

We need to set the environment variable DJANGO_SETTINGS_MODULE to the location of Setting module, conf.settings in this case. conf is the package and settings is a module file, our Settings module.

Why conf? Because when we generate message files from Python scripts and templates — we will see how to generate later, the Django message file generator, make-messages.py, will create files under conf/locale/ from where it’s run.

2   Settings

What do we need in conf/settings.py?

USE_I18N = True

# Valid languages
LANGUAGES = (
    # 'en', 'zh_TW' match the directories in conf/locale/*
    ('en', _('English')),
    ('zh_TW', _('Chinese')),

    # or ('zh-tw', _('Chinese')), # But the directory must still be conf/locale/zh_TW

    )# This is a default languageLANGUAGE_CODE = 'en'

3   Mark the messages

Wraps those need to be translated with _("message") in Python script and {% trans "message" %} in template files. Please read I18N¹ for more usages.

4   Generate message files

Before you run the helper script, we need to create conf/locale, the helper won’t create it for us.

Make sure you are at root of Google App Engine application’s directory, then run:

$ PYTHONPATH=/path/to/googleappengine/python/lib/django/ /path/to/googleappengine/python/lib/django/django/bin/make-messages.py -l en

/path/to/googleappengine/ is the Google App Engine SDK’s location. This command should generate the conf/locale/en/LC_MESSAGE/django.po. Now you can open it to translate.

Don’t forget to set CHARSET, Usually UTF-8 will be fine, the line would read like:

"Content-Type: text/plain; charset=UTF-8\n"

Once you finish translating, you need to run:

$ PYTHONPATH=/path/to/python/googleappengine/lib/django/ /path/to/googleappengine/python/lib/django/django/bin/compile-messages.py

It will generate django.mo files in each language directories. You also need to update when you modify scripts or template, run:

$ PYTHONPATH=/path/to/googleappengine/python/lib/django/ /path/to/googleappengine/python/lib/django/django/bin/make-messages.py -a

This will update all languages in conf/locale.

5   Working?

If you run your application, now it should show the language in conf.settings.LANGUAGE_CODE.

This is a per application setting, which is not normally that we want. We will expect each user can choose their own language. Django has a helper that calls LocaleMiddleware can do the job, unfortunately, it needs Django’s request and response class to work normally.

6   Do the dirty job

In order to do what LocaleMiddleware does, we need to make Google App Engine’s request/response objects have same behavior as Djagno’s. For easing the complexity, we create a new class, I18NRequestHandler, which inherits google.ext.webapp.RequestHandler. You only need to replace with it in your handlers.

import os

from google.appengine.ext import webapp
from django.utils import translation

class I18NRequestHandler(webapp.RequestHandler):

  def initialize(self, request, response):

    webapp.RequestHandler.initialize(self, request, response)

    self.request.COOKIES = Cookies(self)
    self.request.META = os.environ
    self.reset_language()

  def reset_language(self):

    # Decide the language from Cookies/Headers
    language = translation.get_language_from_request(self.request)
    translation.activate(language)
    self.request.LANGUAGE_CODE = translation.get_language()

    # Set headers in response
    self.response.headers['Content-Language'] = translation.get_language()
#    translation.deactivate()

Where Cookies is from http://appengine-cookbook.appspot.com/recipe/a-simple-cookie-class/ (dead link with long gone Cookbook). When request comes in, it can automatically activate the language from what Cookies/Headers specify.

7   Caching problem

It’s not so perfect. I have noticed a problem in development server. If you change code and/or the message file, recompile the message file while server still runs, those message in entry script may not be translated for reflecting to cookie django_language‘s change. I believe that is about the caching.

I am not sure the natural problems, so I couldn’t solve it. However, this may not be severe problem.

8   Encoding

If you use unicode string (not str string) in {% blocktrans %} template tag, you may get error, encode it to utf-8 first, e.g. s.encode('utf-8').

9   Language Code

You must use underscore not dash for messages directory, e.g aa_BB, or Django would not recognize directory named as aa-BB or aa-bb. But in conf.settings you can use aa-bb, this means the language code and directory can be different, e.g. zh-tw for the language code in Python and zh_TW as message directory name.

10   Conclusion

Although this will work, but it may be broken if any changes to Django framework within Google App Engine. There isn’t a good solution for I18N in Google App Engine if Google doesn’t natively support it.

11   Updates

• 2009-11-25: Added not about template module first and encoding issue, and updated the path of Python lib in GAE SDK.
• 2009-12-24: Added a note about Language Code format, thanks BRAGA, again.
• 2010-02-04: Added a note about the Language Code and message directory name.
• 2013-02-17: fix dead links and typos.
• 2013-07-24: remove “.rst” from title, update link.