Django DIY भाग 2: अंतर्राष्ट्रीयकरण

भाग 1

परिचय।

प्रारंभ में, मैं लेख मार्गों में और त्रुटियों के खिलाफ लड़ाई में अधिक उल्लेख करना चाहता था, लेकिन अंतर्राष्ट्रीयकरण का विषय काफी व्यापक था, इसलिए उनके लिए विशेष रूप से एक पद समर्पित करने का निर्णय लिया गया। हम ढांचे के भीतर आम गेटटेक्स्ट टूल का उपयोग करेंगे।

सभी अनुवादों को दो भागों में विभाजित किया जा सकता है:
क) जो विस्तार के साथ सीधे फाइलों में हैं। खटमल - उनके साथ सब कुछ सरल है।
b) और उन टेम्प्लेट में - उन्हें एक छोटी बाइक लिखनी होगी :)।
ठीक है, तो आपको अनुवाद प्रबंधन प्रक्रिया को स्वचालित करने की आवश्यकता है।
तो बिल्ली में आपका स्वागत है।

पायथन फाइलों से अनुवाद वाक्यांश

अनुवाद प्रणाली को कार्य करने के लिए, हम अनुवाद के साथ काम करने वाले फ़ंक्शन को आयात करते हैं, एक तर्क के रूप में हम इसे उस मॉड्यूल के नाम से गुजारते हैं जिसमें हम अनुवाद करते हैं और यही है। अगला, हम बस इस फ़ंक्शन को _ () कहते हैं और अनुवादित वाक्यांश को एक तर्क के रूप में पास करते हैं।

import core.union; _ = core.union.get_trans('module') _('text') 

टेम्प्लेट से वाक्यांशों का अनुवाद

रेंडर_टैम्पल फ़ंक्शन में पेस्ट करें, जो टेम्प्लेट को प्रस्तुत करता है, अनुवाद फंक्शन को टेम्प्लेट में पास करने के लिए निम्न अंश:

 p['gettext'] = get_trans(module) p['_'] = get_trans(module) 

नतीजतन, हम प्राप्त करते हैं:

 def render_templ(template, **kwarg): template = jinja.get_template(template) module = split_templ_name( template)[0] kwarg['gettext'] = get_trans(module) kwarg['_'] = get_trans(module) kwarg['context'] = context() return template.render(**kwarg) 

आप पर्यावरण के संदर्भ को टेम्प्लेट में भी पारित कर सकते हैं ताकि प्रत्येक फ़ंक्शन में इसे पारित न करें।
इसके बाद अनुवाद के साथ काम करने वाले कार्य आते हैं।

 langs = {} def load_lng(path, module_name, lang): """     """ if not module_name in langs[lang]: langs[lang][module_name] = [] path = os.path.join( path, module_name, 'locale') if module_name else os.path.join (path, 'locale') if os.path.isdir(path): t = gettext.translation('_', path, [cur_lang()], codeset='UTF-8') langs[lang][module_name].append(t) def get_lng(module): """     . """ lang = cur_lang() if not lang in langs: langs[lang] = {} if not module in langs[lang]: langs[lang][module] = [] load_lng(os.path.join (settings.lib_path,'app'), module, lang) load_lng(os.path.join (os.getcwd(),'app'), module, lang) if not module: load_lng(os.path.join (os.getcwd()), '', lang) return langs[lang][module] def trans(module, s): """     ,      """ if type(s) == str: s = s.decode('UTF-8') translated = s lng = get_lng(module) if lng: for i in reversed(lng): translated = i.gettext(s).decode('UTF-8') #     translated        . if s != translated: break return translated def get_trans(module): #       return lambda s: trans(module, s) 

गेटटेक्स्ट के साथ काम करें

अब हमें {{_ ('टेक्स्ट')}} टेम्प्लेट में लिखे जाने के बाद अनुवाद को स्वचालित करना होगा। हमें / app / मॉड्यूल / ru / LS_MESSAGES फ़ोल्डरों में _.mo, _.po फाइलें मिलनी चाहिए।
_.mo - संकलित फ़ाइल जहाँ से gettext तब अनुवाद पढ़ता है।
_.po - इस मॉडल के अनुसार अनुवादकों के लिए स्रोत कोड वाली फ़ाइल:

 #: /path/modul/templ/base.tpl:25 msgid "text" msgstr "" #      . 

ये फ़ाइलें कंसोल से मानक कमांड द्वारा प्रबंधित की जाती हैं:
xgettext - अनुवाद के लिए फाइलों से लाइनें एकत्र करता है।
msginit - किसी विशेष भाषा के लिए एक अनुवाद फ़ाइल बनाता है _.po।
msgfmt - _.mo बाइनरी फ़ाइल के लिए संकलित करता है।
msgmerge - अनुवाद फ़ाइलों को अपडेट करें।
लेकिन सबसे पहले, मैं सब कुछ स्वचालित करना चाहूंगा और हर बार कई कमांड नहीं लिखूंगा, और दूसरी बात, xgettext टेम्पलेट्स के साथ काम करने में सक्षम नहीं है, लेकिन केवल * .py फ़ाइलों के साथ, कम से कम उसे ऐसा अवसर नहीं मिला।
इसलिए, हम एक छोटी सी उपयोगिता लिखेंगे कि एक कमांड हमारे लिए इन सभी कार्यों को पूरा करेगा।

 #     . list_lang = ['ru_RU', 'en_US']     . s = str(sys.argv) s = s[1:-1]; app = [] for word in s.split(", "): app.append(word) #      lib_path = '/path' #      app_path = app[1][1:-1] def iter_trans(dir, is_app=True): """             .""" if is_app: #    for res in os.listdir(dir): path_ = os.path.join(dir, res, 'locale') if os.path.isdir(path_): for res in os.listdir(path_): path = os.path.join(path_, res, 'LC_MESSAGES') if os.path.isdir(path): po_f = os.path.join(path, '_.po') mo_f = os.path.join(path, '_.mo') os.popen("msgfmt -o %s %s" % (mo_f, po_f )).read() else: #      . path_ = os.path.join(dir, 'locale') if os.path.isdir(path_): for res in os.listdir(path_): path = os.path.join(path_, res, 'LC_MESSAGES') if os.path.isdir(path): po_f = os.path.join(path, '_.po') mo_f = os.path.join(path, '_.mo') os.popen("msgfmt -o %s %s" % (mo_f, po_f )).read() def iter_mo(dir, is_app=True): """    """ if is_app: for res in os.listdir(dir): path = os.path.join(dir, res, 'templ') if os.path.isdir(path): iter_templ(path) else: path = os.path.join(dir, 'templ') if os.path.isdir(path): iter_templ(path) pot_header = """# SOME DESCRIPTIVE TITLE. # Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER # This file is distributed under the same license as the PACKAGE package. # FIRST AUTHOR <EMAIL@ADDRESS>, YEAR. # msgid "" msgstr "" "Project-Id-Version: PACKAGE VERSION\\n" "Report-Msgid-Bugs-To: \\n" "POT-Creation-Date: %s\\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\\n" "Last-Translator: FULL NAME <EMAIL@ADDRESS>\\n" "Language-Team: LANGUAGE <LL@li.org>\\n" "MIME-Version: 1.0\\n" "Content-Type: text/plain; charset=UTF-8\\n" "Content-Transfer-Encoding: 8bit\\n" """ % (time.strftime("%Y-%m-%d %H:%M%z")) def iter_templ(dir): """           pot .        _.po      . """ out_f = os.path.join(dir, '..', 'locale', '_.pot') file_o = open(out_f, 'w') #    . file_o.write(pot_header) for name in os.listdir(dir): if name.endswith('.tpl'): load_translation(os.path.join(dir, name), file_o) file_o.close() for res in list_lang: lang = res[:2] po_path = os.path.join(dir, '..', 'locale', lang) if not os.path.isdir(po_path): os.makedirs(po_path, 0755) po_path = os.path.join(po_path, 'LC_MESSAGES') if not os.path.isdir(po_path): os.makedirs(po_path, 0755) po_f = os.path.join(po_path, '_.po') if not os.path.isfile(po_f): os.popen("msginit --no-translator -i %s -o %s -l %s" % ( out_f, po_f, res+'.UTF-8')).read() else: os.popen("msgmerge %s %s -o %s" % (po_f, out_f, po_f)).read() def load_translation(in_f, file): """         . """ with open(in_f, 'r') as f: l = f.read().split('\n') n = 0; r = {} for rs in l: n += 1 #     aa = re.findall(r'_\([^)]+\)', rs) for res in aa: #         res = res[3:-2] #       if not res in r: r[res] = [] #    r[res].append(n) for res, nums in r.iteritems(): file.write('#: '+in_f+':'+','.join([str(x) for x in nums])+'\n') file.write('msgid "'+res+'"\n') file.write('msgstr ""\n\n') #       'cpl',  ,  ,    . itr = iter_trans if len(app) > 2 and app[2][1:-1] == 'cpl' else iter_mo for res in [lib_path + '/', False, lib_path +'/app/', app_path +'/app/', app_path + '/', False]: itr(res) 

सारांश

अब रूपरेखा में एक मॉड्यूलर संरचना, मानकीकरण और आंतरिककरण है। एक व्यावहारिक रूपरेखा बनाने के लिए, हमें बस डिबगिंग को जोड़ने की जरूरत है, मार्गों और स्टैटिक्स के साथ काम करना है। उसके बाद, मुख्य घटक बनाना शुरू करना संभव होगा: व्यवस्थापक पैनल, डेटा प्रस्तुति, आदि।
अभी के लिए बस इतना ही।

सामग्री का इस्तेमाल किया

गेटटेक्स्ट की प्रकृति के बारे में
अजगर में गेटेक्स्ट का परिचय
gettext और jinja2
पायथन और गेटटेक्स्ट प्रलेखन

विस्तार