Ticket #1086: dLocalize.4.py

# -*- coding: utf-8 -*-
import gettext
import locale
import os
import dabo

__app_initialized = False
__app_has_locale = False
__dabo_trans = None
__app_trans = None
_localedir = "locale"
_frozenlocaledir = "dabo.locale"

"""
    Beware: if you are using 8-bit (non-Unicode) locales, you could encounter errors like
    "UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-7: ordinal not in range(128)"
    Such error could appear, for example, when comparing non-Unicode string with Unicode string, 
    or when printing Unicode string on non-Unicode console.  
    
    Unfortunately, this is a Python specifics, not a Dabo framework error.
    This is because Python by default use only 7-bit ascii <-> Unicode conversion. 
    e.g. look at http://mail.python.org/pipermail/python-list/2007-March/433232.html
    
    Suggested solutions are: 
    1) Use unicode locale
    2) Modify the site.py, so that locale-aware encoding will be set up (site-wide effect)
    3) Insert following code at the top of app, does the same thing as above (inspired by site.py)

        import sys
        import locale
        reload(sys)
        sys.setdefaultencoding(locale.getdefaultlocale()[1])
        
"""
#TODO:  Maybe, this code should go to the beginning of this file ??? then everything will be ok

def _(s):
    """ Use it to get translated strings.   
    Localization files of app should be in under its locale directory.
    Localization files of dabo framework should be under dabo's locale directory.
    """
    
    global defLang, __app_initialized, __app_has_locale
    
    if not __app_initialized:
        try:
            app = dabo.dAppRef
        except AttributeError:
            app = None
            
        if app:
            __app_initialized = True
            
            appShortName = app.getAppInfo("appShortName").lower()
            # if not changed in user app, defaults to "daboapplication"
            localedir = os.path.join(app.HomeDirectory, _localedir)

            if gettext.find(appShortName, localedir, [defLang,"en"], all = True):
                # application really has some localization file, "en" at least  

                __app_has_locale = True
                setLanguage(domain = appShortName, localedir = localedir)
                __app_trans.add_fallback(__dabo_trans)
                # application's localization is inplace now, dabo's localization is a fallback
            else:
                # app doesn't appear to have a locale directory set up.
                pass

    # as it looks like the default is to use Unicode, then we return Unicode strings
    if __app_initialized and __app_has_locale:
        return __app_trans.ugettext(s)
    else:
        # application's localization is not ready for now, use only dabo's localization
        return __dabo_trans.ugettext(s)

def n_(s):
    """ Use it if you want to tell translation service about string
    but don't want to translate it inplace.
    """
    return s
    #TODO: wouldn't it be better, if we will use something like _("string",False) in _ function ??? 
    # i.e. one more argument for _function, telling by default to translate strings ?
    # def _(s, translate=True):
    #  pkm: Agree. Actually, can someone give an example of when you'd even want this?
    #      Do we use it even?

def setLanguage(lang=None, charset=None, domain="dabo", localedir=None):
    """Use it if you want to switch to another localizations than your default.
    You should call it twice - once for dabo framework, and once for app.
    """
    global defLang, defCharset, __dabo_trans, __app_trans
    
    #TODO: we should search system localizations directory as well

    if localedir is None:
        localedir = os.path.join(os.path.split(dabo.__file__)[0], _localedir)
        if not os.path.exists(localedir):
            localedir = os.path.join(os.getcwd(), _frozenlocaledir)

    if charset is None:
        charset = defCharset

    if lang is None:
        lang = defLang
    else:
        lang = lang.lower()
        # It might be the full name instead of the two-letter abbreviation
        if lang not in getLanguages():
            try:
                lang = {"english": "en",
                        "spanish": "es", "espanol": "es", "español": "es",
                        "french": "fr", "francais": "fr", "français": "fr", 
                        "german": "de", "deutsch": "de",
                        "italian": "it", "italiano": "it", 
                        "portuguese": "pt", "portuguése": "pt",
                        "russian": "ru"}[lang]
            except KeyError:
                pass
        
    dabolocalefile = gettext.find(domain, localedir, languages=[lang], all=True)
    print dabolocalefile

    if not dabolocalefile:
        print "Gettext file for language %s was not found , falling back to english" % lang 

        dabolocalefile = gettext.find(domain, localedir, languages = ['en'], all=True)
    
        if not dabolocalefile:
            raise IOError, "Neither english nor '%s' language was found " % lang
    
        defLang = "en"
        defCharset = "UTF-8"

    if domain == "dabo":
        __dabo_trans = gettext.translation(domain, localedir, languages=[lang], codeset=charset)
        defLang = lang
    else:
        __app_trans = gettext.translation(domain, localedir, languages=[lang], codeset=charset)
        
defLang, defCharset = locale.getdefaultlocale()

if defLang is None:
    defLang = "en"
else:
    defLang = defLang[:2]
if defCharset is None:
    defCharset = "UTF-8"
    
setLanguage()

if __name__ == "__main__":
    # this code is important for every non-unicode locale  
    import sys
    import locale
    reload(sys)
    sys.setdefaultencoding(locale.getdefaultlocale()[1])
    
    print 'user locale is ', locale.getdefaultlocale()
    print 'framework locale is ', defLang, defCharset
    print _("Framework localization test")