検証情報yamlの記述方法、使い方ともにSymfonyのValidationManagerに酷似していると思います。なので、Symfonyを使ったことがある人であれば、なんとなくわかりやすいかもしれません。と言っても、SymfonyのValidationManagerほどまだ細部までエラーチェックなどをしていないので、検証情報yamlの記述によっては、予期しないエラーが発生すると思います。ですので、この辺は、もう少しリファクタリングをしないといけないかと思います。

Pythonによるリフレクション部分だったりdb.Modelの扱い方がもし間違っていたら是非教えてください。

今回、関係するソースは下記に載せておきます。

■検証情報yaml

validate:
  name:
    - validator: RequiredValidator

■ValidationManager

class ValidationManager(object):
    VALIDATOR_PACKAGES = [
                          'org.fukata.mapshare.system.utils.validation.common.',
                          'org.fukata.mapshare.system.utils.validation.extention.',
                          ]
    
    valid = None
    errors = None
    
    def __init__(self,validYaml):
        self.valid = YamlUtils.load(validYaml)
        
    def validate(self,model):
        # initialize
        self.errors = Errors()
        
        for item in self.valid[config.VALIDATE_KEY]:
            for validInfo in self.valid[config.VALIDATE_KEY][item]:
                validator = self._getValidatorInstance(validInfo)
                # check exists attribute
                props = model.properties()
                prop = None
                if props.has_key(item):
                    prop = props[item]
                else:
                    # don't have a key.
                    raise BadKeyError("Key %s is don't have property." % item)
                
                value = getattr(model, prop._attr_name(), None)
                try:
                    validator.validate(value, prop, model)
                except ValidationError, e:
                    self.errors.append(prop, e.__str__())
                
        return not bool(self.errors)
    
    def _getValidatorInstance(self, validInfo):

        clazz = ReflectionUtils.getClazz(validInfo['validator'], self.VALIDATOR_PACKAGES);
        options = validInfo['options'] if validInfo.has_key('options') else {} 
        return clazz(options)

■ValidationError

class ValidationError(Exception):
    def __init__(self, value):
        self.value = value
        
    def __str__(self):
        return self.value

■BaseValidator

class BaseValidator(object):
    options = None

    def __init__(self, options=None):
        self.options = options
        
    def validate(self,value,prop,model):
        return False

■RequiredValidator

class RequiredValidator(BaseValidator):
    def validate(self,value,prop,model):
        if value is None:
            raise ValidationError('Property %s is required' % prop.name)

        if StringUtils.isNone(value):
            raise ValidationError('Property %s is required' % prop.name)
        
        return True

■BaseModel

# skip default validation of db.Property
setattr(db.Property, '__set__', 
        lambda self, model_instance, value: 
            setattr(model_instance, self._attr_name(), value))

class BaseModel(db.Model):
    errors = None

    def __init__(self, *args, **kwds):
        super(BaseModel, self).__init__(*args, **kwds)
        self.errors = Errors()

    def validate(self,valid_yaml=None):
        if valid_yaml is None:
            for prop in self.properties().values():
                value = getattr(self, prop._attr_name(), None)
                try:
                    value = prop.validate(value)
                    setattr(self, prop._attr_name(), value)
                except db.BadValueError, e:
                    self.errors.append(prop, e.message)
            return not bool(self.errors)
        else:
            manager = ValidationManager(valid_yaml)
            manager.validate(self)
            self.errors = manager.errors
            return not bool(self.errors)

■Errors

class Errors(list):
    '''container of validation errors
    '''
    def __init__(self):
        self.map = dict()

    def append(self, prop, msg=None, error=True):
        if error:
            if isinstance(prop, db.Property):
                super(Errors, self).append(Error(prop, msg))
                self.map[prop.name] = len(self) - 1
            elif isinstance(prop, (str, unicode)):
                super(Errors, self).append(Error(prop, msg))
                self.map[prop] = len(self) - 1
            else:
                super(Errors, self).append(Error(None, prop))

    def clear(self):
        del self[:]
    
    def get(self, index, default=None):
        return self[index] if index in self else default

    def tostr(self, sep=u"\n", **ops):
        msgs=list()
        for error in self:
            msgs.append(error.tostr(**ops))
        return sep.join(msgs)

    def __str__(self):
        return self.tostr()

    def __contains__(self, name):
        return name in self.map
    
    def __getitem__(self, index):
        if isinstance(index, (str, unicode)):
            if index not in self.map:
                raise IndexError(u"'%s' property has not error." % index)
            index = self.map[index]
        return super(Errors, self).__getitem__(index)

■Error

class Error(object):
    '''container of validation error
    '''
    
    def __init__(self, prop, msg=None):
        self.prop = prop
        self.msg = msg

    def __str__(self):
        return self.tostr()

    def tostr(self, format=u"%(msg)s"):
        if isinstance(self.prop, db.Property) and format:
            name = self.prop.verbose_name or self.prop.name
            msg = re.sub(' '+name+' ', ' %(name)s ', self.msg)
            format = format % {
                            'msg': msg,
                        }
            return _(format) % {
                             'name': _(self.prop.verbose_name) or _(self.prop.name),
                            }
        else:
            return _(self.msg)

■ReflectionUtils

class ReflectionUtils(object):
    BIG_PATTERN = re.compile('[A-Z]')
    
    @classmethod
    def getClazz(cls,className,basePackageList=[]):
        packageName = cls.generatePackageName(className)
        
        clazz = None
        if len(basePackageList)>0:
            for basePackage in basePackageList:
                packageName = basePackage+packageName
                try:
                    module = __import__(packageName, globals(), locals(), [className])
                    clazz = getattr(module, className)
                except ImportError, e:
                    continue
                except AttributeError, e:
                    continue
        else:
            try:
                module = __import__(packageName, globals(), locals(), [className])
                clazz = getattr(module, className)
            except ImportError, e:
                pass
            except AttributeError, e:
                pass
        
        if clazz is None:
            raise AttributeError('%s class is not exists.' % className)
        
        return clazz
        
    
    @classmethod
    def newInstance(cls,className,basePackageList=[]):
        try:
            clazz = cls.getClazz(className, basePackageList)
            instance = clazz()
        except ImportError, e:
            pass
        except AttributeError, e:
            pass
        
        if instance is None:
            raise AttributeError('%s is not exists.' % className)
        
        return instance
    
    @classmethod
    def generatePackageName(cls,className):
        split = cls.BIG_PATTERN.split(className)
        findall = cls.BIG_PATTERN.findall(className)
        
        str_list = []
        white=0
        for i in range(len(split)):
            if split[i]:
                head = findall[i-white].lower()
                str = head+split[i]
                str_list.append(str)
            else:
                white = white+1
                
        return '_'.join(str_list)

■YamlUtils

class YamlUtils(object):
    
    @classmethod
    def load(cls,path):
        return yaml.load(cls._get_stream(path))
    
    @classmethod
    def load_all(cls,path):
        return yaml.load_all(cls._get_stream(path))
    
    @classmethod
    def _get_stream(cls,path):
        fp = open(path, 'r')
        stream = fp.read()
        fp.close()
        return stream

それにしても、まだ、Pythonのコードをちゃんと理解していないんだなと感じさせられました。あぁ、早く好きなようにカスタマイズできるようになりたいw

前の記事で書いていた「Environment variable DJANGO_SETTINGS_MODULE is undefined.」のエラーについてですが、あの記事を書いた後も何度か発生しており、今日、GAE上にアップしたアプリを動かしていると、一時ページを表示した状態で放置し、改めて操作するとAjax部分の通信で上記のエラーが出ていました。

それで、色々調べているとimportの順番が問題だったようで、試してみるとエラーが出なくなりました。その修正内容を書いておきたいと思います。

■編集前

from django.utils import translation
from google.appengine.ext import webapp
from org.fukata.mapshare.system.utils.cookies import Cookies
import os
from django.conf import settings

os.environ.__setitem__('DJANGO_SETTINGS_MODULE', 'conf.settings')
# Force Django to reload settings
settings._target = None

■編集後

import os
from google.appengine.ext import webapp
from google.appengine.ext.webapp import template
from django.utils import translation
from org.fukata.mapshare.system.utils.cookies import Cookies
from django.conf import settings

os.environ.__setitem__('DJANGO_SETTINGS_MODULE', 'conf.settings')
# Force Django to reload settings
settings._target = None

全体的に順序も入れ替わってしまっているので分かりにくいと思いますが、

from django.utils import translation

の前に

from google.appengine.ext import webapp
from google.appengine.ext.webapp import template

を読み込むということです。

また、エラーが出るようでしたら追記したいと思います。これで、最後であってほしい。。。（直接的な原因を調べろよ。。。）

■UnicodeDecodeErrorの発生
実際にアップロードして、.poファイルで日本語が定義しているmsgidが存在するページを開いた際に同様のエラーが発生しました。これは、.poファイルの文字コードが設定されていなかった為に起こったようです。下記が、現在の.poファイルになります。

msgid ""
msgstr ""
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Last-Translator: Tatsuya Fukata \n"
"Report-Msgid-Bugs-To: Tatsuya Fukata \n"
"Language-Team: Japanese\n"
"Project-Id-Version: MapShare\n"

msgid "Spot"
msgstr "スポット"

msgid "Spot List"
msgstr "スポット一覧"

msgid "other"
msgstr "その他"

■DJANGO_SETTINGS_MODULEの未設定
次に、何度かデプロイしている間に上記のようなエラーが発生するようになりました。実際に使われているのは前の記事で作成したクラス「I18NRequestHandler」のファイル内で同様の記述が存在します。直接キーを指定している部分を下記のように修正して、エラーが出なくなりました。

#os.environ['DJANGO_SETTINGS_MODULE'] = 'conf.settings'
os.environ.__setitem__('DJANGO_SETTINGS_MODULE', 'conf.settings')

まだ、完全に国際化に対応されていないかもしれませんが、何かエラーが発生したら随時載せていきたいと思います。

多分、次に作成するなら、標準の環境ではなく、他のFWを試すかもしれません。

とまぁ、自分のことは置いといて早速、国際化の手順を書いていきたいと思います。まずは、最終的な構成を書きます。

.
`-- src
    |-- app.yaml
    |-- conf
    |   |-- locale
    |   |   |-- en
    |   |   |   `-- LC_MESSAGES
    |   |   |       |-- django.mo
    |   |   |       `-- django.po
    |   |   `-- ja
    |   |       `-- LC_MESSAGES
    |   |           |-- django.mo
    |   |           `-- django.po
    |   `-- settings.py
    `-- org
        `-- fukata
            `-- mapshare
                |-- public
                |   |-- css
                |   |-- img
                |   `-- js
                `-- system
                    |-- handler
                    |   |-- i18NRequestHandler.py
                    |   |-- pc
                    |   |   `-- index.py
                    |   `-- webapi
                    |-- model
                    |-- template
                    |   `-- pc
                    `-- utils
                         `-- cookies.py

今回、国際化の為に新規に追加のは以下のファイル群都なります。

• config/settings.py
• config/locale/*
• org/fukata/mapshare/system/i18NRequestHandler.py
• org/fukata/mapshare/system/utils/cookies.py

次に各ファイルの内容になります。言語ファイル（.po, .mo）に関しては省きたいと思います。

■config/settings.py

 USE_I18N = True
 
 # Valid languages
 LANGUAGES = (
     # 'en', 'zh_TW' should match the directories in conf/locale/*
     ('en', _('English')),
     ('ja', _('Japanese')),
     )
 
 # This is a default language
 LANGUAGE_CODE = 'ja'

■org/fukata/mapshare/system/i18NRequestHandler.py

 from django.utils import translation
 from google.appengine.ext import webapp
 from org.fukata.mapshare.system.utils.cookies import Cookies
 import os
 
 os.environ['DJANGO_SETTINGS_MODULE'] = 'conf.settings'
 from django.conf import settings
 # Force Django to reload settings
 settings._target = None
 
 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()

■org/fukata/mapshare/system/utils/cookies.py

 import UserDict
 from Cookie import BaseCookie
 class Cookies(UserDict.DictMixin):
     def __init__(self, handler, **policy):
         self.response = handler.response
         self._in = handler.request.cookies
         self.policy = policy
         if 'secure' not in policy and handler.request.environ.get('HTTPS', '').lower() in ['on', 'true']:
             policy['secure'] = True
         self._out = {}
     def __getitem__(self, key):
         if key in self._out:
             return self._out[key]
         if key in self._in:
             return self._in[key]
         raise KeyError(key)
     def __setitem__(self, key, item):
         self._out[key] = item
         self.set_cookie(key, item, **self.policy)
     def __contains__(self, key):
         return key in self._in or key in self._out
     def keys(self):
         return self._in.keys() + self._out.keys()
     def __delitem__(self, key):
         if key in self._out:
             del self._out[key]
             self.unset_cookie(key)
         if key in self._in:
             del self._in[key]
             p = {}
             if 'path' in self.policy: p['path'] = self.policy['path']
             if 'domain' in self.policy: p['domain'] = self.policy['domain']
             self.delete_cookie(key, **p)
     #begin WebOb functions
     def set_cookie(self, key, value='', max_age=None,
                    path='/', domain=None, secure=None, httponly=False,
                    version=None, comment=None):
         """
         Set (add) a cookie for the response
         """
         cookies = BaseCookie()
         cookies[key] = value
         for var_name, var_value in [
             ('max-age', max_age),
             ('path', path),
             ('domain', domain),
             ('secure', secure),
             ('HttpOnly', httponly),
             ('version', version),
             ('comment', comment),
             ]:
             if var_value is not None and var_value is not False:
                 cookies[key][var_name] = str(var_value)
             if max_age is not None:
                 cookies[key]['expires'] = max_age
         header_value = cookies[key].output(header='').lstrip()
         self.response.headers._headers.append(('Set-Cookie', header_value))
     def delete_cookie(self, key, path='/', domain=None):
         """
         Delete a cookie from the client.  Note that path and domain must match
         how the cookie was originally set.
         This sets the cookie to the empty string, and max_age=0 so
         that it should expire immediately.
         """
         self.set_cookie(key, '', path=path, domain=domain,
                         max_age=0)
     def unset_cookie(self, key):
         """
         Unset a cookie with the given name (remove it from the
         response).  If there are multiple cookies (e.g., two cookies
         with the same name and different paths or domains), all such
         cookies will be deleted.
         """
         existing = self.response.headers.get_all('Set-Cookie')
         if not existing:
             raise KeyError(
                 "No cookies at all have been set")
         del self.response.headers['Set-Cookie']
         found = False
         for header in existing:
             cookies = BaseCookie()
             cookies.load(header)
             if key in cookies:
                 found = True
                 del cookies[key]
             header = cookies.output(header='').lstrip()
             if header:
                 self.response.headers.add('Set-Cookie', header)
         if not found:
             raise KeyError(
                 "No cookie has been set with the name %r" % key)

となります。で、通常のハンドラに対して「webapp.RequestHandler」ではなく、「I18NRequestHandler」を継承するようにします。これで、基本的には大丈夫です。テンプレート内で、国際化のタグを使用するには、テンプレートの先頭などで、{% load i18n %}と記述します。これで、国際化用のタグが使えるようになります。

また、.poファイルに関してですが、sdkにスクリプトが付随しているようですが、自分は下記のように.moファイルを生成しています。まぁ、スクリプトを使った方が便利だと思います^^;

msgfmt django.po 
mv messages.mo  django.mo

今回使用した、コードに関しては、参考サイトの方にほぼすべてあります。というか、掲載されているコードそのままで動きました。

■参考サイト

• https://makeyjl.blogspot.com/2009/02/using-djangos-i18n-in-google-app-engine.html

■A.py

class A(db.Model):
    owner = db.UserProperty(required=True,auto_current_user_add=True)

■B.py

class B(db.Model):
    a = db.ReferenceProperty(required=True,reference_class=A)

■main.py

a_key = [エンティティAのKeyを取得]
a = A.get(a_key)
# コンストラクタで指定しないと登録時にエラーになります。
b = B(a=a)
# 以下のようにフィールドを指定して代入してもエラーとなる。
b.a = a
b.put()

ずっと、後者のようにフィールドを指定して代入していたので、「なんで代入してるのにエラーになるんだ？」という風に思っていて、コンストラクタに指定するというのに気づくのがかなり遅くなってしまいました。

とりあえず、なんとか登録することもでき、前に進むことができるようになりました。今作っているアプリはjsごりごりのアプリなので、デバッグがいつもに比べ手間がかかります＾＾；しかも、Python自体もまだ勉強し始めてそんなに時間が経っていないのでどういう関数があるのかすら分からない状態で、常にググりながらのコーディングとなっています。