Django 2.1

Translation




django

Translation

अवलोकन

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

Django तब अनुवाद स्ट्रिंग्स को एक संदेश फ़ाइल में निकालने के लिए उपयोगिताओं प्रदान करता है। यह फ़ाइल अनुवादकों के लिए लक्ष्य भाषा में अनुवाद के तार के बराबर प्रदान करने का एक सुविधाजनक तरीका है। संदेश फ़ाइल में अनुवादक भरे जाने के बाद, इसे संकलित किया जाना चाहिए। यह प्रक्रिया GNU गेटटेक्स्ट टूलसेट पर निर्भर करती है।

ऐसा होने के बाद, उपयोगकर्ताओं की भाषा की प्राथमिकताओं के अनुसार, Django प्रत्येक उपलब्ध भाषा में मक्खी पर वेब ऐप्स का अनुवाद करने का ध्यान रखता है।

Django के अंतर्राष्ट्रीयकरण हुक डिफ़ॉल्ट रूप से हैं, और इसका मतलब है कि फ्रेमवर्क के कुछ स्थानों में i18n से संबंधित ओवरहेड का एक सा है। यदि आप अंतर्राष्ट्रीयकरण का उपयोग नहीं करते हैं, तो आपको अपनी सेटिंग फ़ाइल में USE_I18N = False सेट करने के लिए दो सेकंड का समय लेना चाहिए। फिर Django कुछ अनुकूलन करेगा ताकि अंतर्राष्ट्रीयकरण मशीनरी को लोड न किया जाए।

ध्यान दें

एक स्वतंत्र लेकिन संबंधित USE_L10N सेटिंग है जो नियंत्रित करता है कि क्या Django प्रारूप स्थानीयकरण को लागू करे। अधिक विवरण के लिए प्रारूप स्थानीयकरण देखें।

ध्यान दें

सुनिश्चित करें कि आपने अपनी परियोजना के लिए अनुवाद सक्रिय कर दिया है (सबसे तेज़ तरीका यह देखने के लिए है कि MIDDLEWARE में django.middleware.locale.LocaleMiddleware शामिल है)। यदि आपने अभी तक नहीं देखा है, तो देखें कि कैसे Django भाषा को प्राथमिकता देता है

अंतर्राष्ट्रीयकरण: पायथन कोड में

मानक अनुवाद

फ़ंक्शन gettext() का उपयोग करके अनुवाद स्ट्रिंग निर्दिष्ट करें। टाइपिंग को बचाने के लिए, यह एक छोटे उर्फ, _ रूप में आयात करने के लिए सम्मेलन है।

ध्यान दें

gettext फ़ंक्शंस का u प्रीफ़िक्सिंग मूल रूप से पायथन 2 में यूनिकोड स्ट्रिंग्स और बाइटस्ट्रेस के बीच उपयोग को भेद करने के लिए था। कोड के लिए जो केवल पायथन 3 का समर्थन करता है, उनका उपयोग परस्पर किया जा सकता है। भविष्य के Django रिलीज़ में उपसर्ग किए गए फ़ंक्शंस के लिए एक अवमूल्यन हो सकता है।

ध्यान दें

पायथन के मानक पुस्तकालय gettext मॉड्यूल _() को वैश्विक नाम स्थान में स्थापित करता है, gettext() लिए एक उपनाम के रूप में gettext() । Django में, हमने कुछ कारणों से इस प्रथा का पालन नहीं करने का फैसला किया है:

  1. कभी-कभी, आपको किसी विशेष फ़ाइल के लिए डिफ़ॉल्ट अनुवाद विधि के रूप में gettext_lazy() उपयोग करना चाहिए। वैश्विक नाम स्थान में _() बिना, डेवलपर को यह सोचना होगा कि सबसे उपयुक्त अनुवाद फ़ंक्शन कौन सा है।
  2. अंडरस्कोर कैरेक्टर ( _ ) का इस्तेमाल पायथन के इंटरेक्टिव शेल और डॉकस्ट टेस्ट में "पिछले परिणाम" का प्रतिनिधित्व करने के लिए किया जाता है। एक वैश्विक _() फ़ंक्शन को स्थापित करने से हस्तक्षेप होता है। स्पष्ट रूप से gettext() as _() आयात करना इस समस्या से बचा जाता है।

क्या कार्यों के रूप में aliased हो सकता है _ ?

क्योंकि makemessages ( makemessages द्वारा उपयोग किया जाता है) कैसे काम करता है, केवल एक स्ट्रिंग तर्क लेने वाले कार्यों को _ रूप में आयात किया जा सकता है:

इस उदाहरण में, पाठ "Welcome to my site." अनुवाद स्ट्रिंग के रूप में चिह्नित किया गया है:

from django.http import HttpResponse
from django.utils.translation import gettext as _

def my_view(request):
    output = _("Welcome to my site.")
    return HttpResponse(output)

जाहिर है, आप इस उपनाम का उपयोग किए बिना कोड कर सकते हैं। यह उदाहरण पिछले एक के समान है:

from django.http import HttpResponse
from django.utils.translation import gettext

def my_view(request):
    output = gettext("Welcome to my site.")
    return HttpResponse(output)

अनुवाद कम्प्यूटेड मूल्यों पर काम करता है। यह उदाहरण पिछले दो के समान है:

def my_view(request):
    words = ['Welcome', 'to', 'my', 'site.']
    output = _(' '.join(words))
    return HttpResponse(output)

अनुवाद चर पर काम करता है। फिर, यहाँ एक समान उदाहरण है:

def my_view(request):
    sentence = 'Welcome to my site.'
    output = _(sentence)
    return HttpResponse(output)

(पिछले दो उदाहरणों के अनुसार, चर या संगणित मूल्यों का उपयोग करते हुए, यह है कि Django के अनुवाद-स्ट्रिंग-डिटेक्टिंग यूटिलिटी, makemessages , इन स्ट्रिंग्स को खोजने में सक्षम नहीं होंगे। बाद में makemessages पर अधिक।)

आपके द्वारा पास किए गए तार _() या gettext() प्लेसहोल्डर्स ले सकते हैं, जो पायथन के मानक नाम-स्ट्रिंग प्रक्षेप सिंटैक्स के साथ निर्दिष्ट किया गया है। उदाहरण:

def my_view(request, m, d):
    output = _('Today is %(month)s %(day)s.') % {'month': m, 'day': d}
    return HttpResponse(output)

यह तकनीक भाषा-विशिष्ट अनुवादों को प्लेसहोल्डर पाठ को फिर से लिखने की सुविधा देती है। उदाहरण के लिए, एक अंग्रेजी अनुवाद "Today is November 26." , जबकि एक स्पेनिश अनुवाद "Hoy es 26 de Noviembre." हो सकता है "Hoy es 26 de Noviembre." - महीने और दिन के साथ प्लेसहोल्डर्स की अदला-बदली।

इस कारण से, जब भी आपके पास एक से अधिक पैरामीटर होते हैं, तो आपको स्थितीय प्रक्षेप (जैसे, %s या %d ) के बजाय नाम-स्ट्रिंग प्रक्षेप (जैसे, %(day)s ) का उपयोग करना चाहिए। यदि आपने स्थिति-संबंधी प्रक्षेप का उपयोग किया है, तो अनुवाद प्लेसहोल्डर पाठ को पुन: व्यवस्थित करने में सक्षम नहीं होंगे।

चूंकि स्ट्रिंग निष्कर्षण xgettext कमांड द्वारा किया जाता है, केवल गेटटेक्स द्वारा समर्थित gettext को Django द्वारा समर्थित किया जाता है। अजगर f-strings और जावास्क्रिप्ट टेम्पलेट स्ट्रिंग्स अभी तक xgettext द्वारा समर्थित नहीं हैं।

अनुवादकों के लिए टिप्पणियाँ

यदि आप अनुवादक को अनुवाद योग्य स्ट्रिंग के बारे में संकेत देना चाहते हैं, तो आप स्ट्रिंग से पहले वाली लाइन पर Translators कीवर्ड के साथ एक टिप्पणी जोड़ सकते हैं, जैसे:

def my_view(request):
    # Translators: This message appears on the home page only
    output = gettext("Welcome to my site.")

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

ध्यान दें

पूर्णता के लिए, यह परिणामी .po फ़ाइल का संगत अंश है:

#. Translators: This message appears on the home page only
# path/to/python/file.py:123
msgid "Welcome to my site."
msgstr ""

यह टेम्प्लेट में भी काम करता है। अधिक विवरण के लिए टेम्प्लेट में अनुवादक के लिए टिप्पणियां देखें।

स्ट्रिंग को नो-ऑप के रूप में चिह्नित करना

एक स्ट्रिंग को बिना अनुवाद के स्ट्रिंग के रूप में चिह्नित करने के लिए फ़ंक्शन django.utils.translation.gettext_noop() का उपयोग करें। स्ट्रिंग को बाद में एक चर से अनुवादित किया गया है।

इसका उपयोग करें यदि आपके पास लगातार तार हैं जिन्हें स्रोत भाषा में संग्रहीत किया जाना चाहिए क्योंकि उनका सिस्टम या उपयोगकर्ताओं पर आदान-प्रदान किया जाता है - जैसे कि डेटाबेस में तार - लेकिन समय में अंतिम संभावित बिंदु पर अनुवाद किया जाना चाहिए, जैसे कि जब स्ट्रिंग प्रस्तुत किया जाता है। उपयोगकर्ता के लिए।

Pluralization

बहुवचन संदेशों को निर्दिष्ट करने के लिए फ़ंक्शन django.utils.translation.ngettext() का उपयोग करें।

ngettext() में तीन तर्क होते हैं: एकवचन अनुवाद स्ट्रिंग, बहुवचन अनुवाद स्ट्रिंग और वस्तुओं की संख्या।

यह फ़ंक्शन तब उपयोगी होता है जब आपको अपने Django एप्लिकेशन को उन भाषाओं के लिए स्थानीय बनाने की आवश्यकता होती है, जहां बहुवचन रूपों की संख्या और जटिलता अंग्रेजी में उपयोग किए जाने वाले दो रूपों से अधिक होती है (सभी वस्तुओं के लिए 'ऑब्जेक्ट' और उन सभी मामलों के लिए जहां count है एक से अलग, इसके मूल्य के बावजूद।)

उदाहरण के लिए:

from django.http import HttpResponse
from django.utils.translation import ngettext

def hello_world(request, count):
    page = ngettext(
        'there is %(count)d object',
        'there are %(count)d objects',
    count) % {
        'count': count,
    }
    return HttpResponse(page)

इस उदाहरण में count चर के रूप में अनुवाद भाषाओं में वस्तुओं की संख्या को पारित किया जाता है।

ध्यान दें कि बहुवचन जटिल है और प्रत्येक भाषा में अलग तरह से काम करता है। 1 से count तुलना हमेशा सही नियम नहीं है। यह कोड परिष्कृत दिखता है, लेकिन कुछ भाषाओं के लिए गलत परिणाम देगा:

from django.utils.translation import ngettext
from myapp.models import Report

count = Report.objects.count()
if count == 1:
    name = Report._meta.verbose_name
else:
    name = Report._meta.verbose_name_plural

text = ngettext(
    'There is %(count)d %(name)s available.',
    'There are %(count)d %(name)s available.',
    count
) % {
    'count': count,
    'name': name
}

अपने स्वयं के एकवचन-या-बहुवचन तर्क को लागू करने का प्रयास न करें; यह सही नहीं होगा। इस तरह से एक मामले में, निम्नलिखित की तरह कुछ पर विचार करें:

text = ngettext(
    'There is %(count)d %(name)s object available.',
    'There are %(count)d %(name)s objects available.',
    count
) % {
    'count': count,
    'name': Report._meta.verbose_name,
}

ध्यान दें

ngettext() का उपयोग करते ngettext() , सुनिश्चित करें कि आप शाब्दिक रूप से शामिल प्रत्येक अतिरिक्त चर के लिए एक ही नाम का उपयोग करते हैं। ऊपर दिए गए उदाहरणों में, ध्यान दें कि हम दोनों अनुवाद स्ट्रिंग में पायथन चर name उपयोग कैसे करते हैं। यह उदाहरण, ऊपर उल्लिखित कुछ भाषाओं में गलत होने के अलावा, विफल होगा:

text = ngettext(
    'There is %(count)d %(name)s available.',
    'There are %(count)d %(plural_name)s available.',
    count
) % {
    'count': Report.objects.count(),
    'name': Report._meta.verbose_name,
    'plural_name': Report._meta.verbose_name_plural
}

django-admin compilemessages चलाते समय आपको एक त्रुटि django-admin compilemessages :

a format specification for argument 'name', as in 'msgstr[0]', doesn't exist in 'msgid'

ध्यान दें

बहुवचन रूप और पीओ फाइलें

Django कवि फ़ाइलों में कस्टम बहुवचन समीकरणों का समर्थन नहीं करता है। जैसा कि सभी अनुवाद कैटलॉग को मर्ज किया जाता है, केवल मुख्य Django po फ़ाइल ( django/conf/locale/<lang_code>/LC_MESSAGES/django.po ) को बहुवचन रूप माना जाता है। अन्य सभी कवि फाइलों में बहुवचन रूपों को नजरअंदाज किया जाता है। इसलिए, आपको अपनी परियोजना या एप्लिकेशन पीओ फाइलों में विभिन्न बहुवचन समीकरणों का उपयोग नहीं करना चाहिए।

प्रासंगिक मार्कर

कभी-कभी शब्दों के कई अर्थ होते हैं, जैसे अंग्रेजी में "May" , जो एक महीने के नाम और एक क्रिया को संदर्भित करता है। अनुवादकों को इन शब्दों को अलग-अलग संदर्भों में सही ढंग से अनुवाद करने में सक्षम करने के लिए, आप django.utils.translation.pgettext() फ़ंक्शन, या django.utils.translation.pgettext() फ़ंक्शन का उपयोग कर सकते हैं यदि स्ट्रिंग को बहुवचन की आवश्यकता है। दोनों पहले चर के रूप में एक संदर्भ स्ट्रिंग लेते हैं।

परिणामी .po फ़ाइल में, स्ट्रिंग तब दिखाई देगी जैसा कि अक्सर एक ही स्ट्रिंग के लिए अलग-अलग संदर्भ मार्कर होते हैं (संदर्भ msgctxt लाइन पर दिखाई देगा), अनुवादक को उनमें से प्रत्येक के लिए एक अलग अनुवाद देने की अनुमति देता है।

उदाहरण के लिए:

from django.utils.translation import pgettext

month = pgettext("month name", "May")

या:

from django.db import models
from django.utils.translation import pgettext_lazy

class MyThing(models.Model):
    name = models.CharField(help_text=pgettext_lazy(
        'help text for MyThing model', 'This is the help text'))

निम्न .po फ़ाइल में दिखाई देगा:

msgctxt "month name"
msgid "May"
msgstr ""

प्रासंगिक मार्करों को trans और blocktrans टेम्प्लेट टैग द्वारा भी समर्थित किया जाता है।

आलसी अनुवाद

django.utils.translation में अनुवाद कार्यों के आलसी संस्करणों का उपयोग करें (आसानी से उनके नामों में lazy प्रत्यय द्वारा आसानी से पहचाने जाने योग्य) तार का अनुवाद करने के लिए आलसी - जब मूल्य को एक्सेस किया जाता है जब वे कहते हैं।

ये फ़ंक्शन स्ट्रिंग का एक आलसी संदर्भ संग्रहीत करते हैं - वास्तविक अनुवाद नहीं। अनुवाद स्वयं किया जाएगा जब स्ट्रिंग का उपयोग स्ट्रिंग संदर्भ में किया जाएगा, जैसे कि टेम्पलेट रेंडरिंग में।

यह आवश्यक है जब इन कार्यों के लिए कॉल कोड पथ में स्थित होते हैं जो मॉड्यूल लोड समय पर निष्पादित होते हैं।

यह कुछ ऐसा है जो मॉडल, रूप और मॉडल रूपों को परिभाषित करते समय आसानी से हो सकता है, क्योंकि Django इनको लागू करता है कि उनके क्षेत्र वास्तव में वर्ग-स्तरीय विशेषता हैं। उस कारण से, निम्नलिखित मामलों में आलसी अनुवाद का उपयोग करना सुनिश्चित करें:

मॉडल फ़ील्ड और रिश्ते verbose_name और verbose_name विकल्प मान

उदाहरण के लिए, निम्नलिखित मॉडल में नाम फ़ील्ड के मदद पाठ का अनुवाद करने के लिए, निम्नलिखित करें:

from django.db import models
from django.utils.translation import gettext_lazy as _

class MyThing(models.Model):
    name = models.CharField(help_text=_('This is the help text'))

आप OneToOneField के नाम, OneToOneField या OneToOneField संबंधों को उनके verbose_name विकल्पों का उपयोग करके अनुवाद करने OneToOneField के रूप में चिह्नित कर सकते हैं:

class MyThing(models.Model):
    kind = models.ForeignKey(
        ThingKind,
        on_delete=models.CASCADE,
        related_name='kinds',
        verbose_name=_('kind'),
    )

जैसे आप verbose_name में करते हैं verbose_name आपको verbose_name लिए एक लोअरकेस वर्बोस नाम टेक्स्ट प्रदान करना चाहिए क्योंकि आवश्यकता पड़ने पर Django स्वचालित रूप से इसका शीर्षक देगा।

मॉडल क्रिया नाम मान

यह सलाह दी जाती है कि सदैव फालबैक अंग्रेजी-केंद्रित पर निर्भर रहने के बजाय स्पष्ट verbose_name और verbose_name_plural विकल्प प्रदान करें और verbose_name_plural नाम का कुछ हद तक दृढ़ निश्चय न करें verbose_name_plural मॉडल के वर्ग के नाम को देखकर करता है:

from django.db import models
from django.utils.translation import gettext_lazy as _

class MyThing(models.Model):
    name = models.CharField(_('name'), help_text=_('This is the help text'))

    class Meta:
        verbose_name = _('my thing')
        verbose_name_plural = _('my things')

मॉडल के तरीके short_description विशेषता मान

मॉडल विधियों के लिए, आप Django और short_description विशेषता के साथ व्यवस्थापक साइट पर अनुवाद प्रदान कर सकते हैं:

from django.db import models
from django.utils.translation import gettext_lazy as _

class MyThing(models.Model):
    kind = models.ForeignKey(
        ThingKind,
        on_delete=models.CASCADE,
        related_name='kinds',
        verbose_name=_('kind'),
    )

    def is_mouse(self):
        return self.kind.type == MOUSE_TYPE
    is_mouse.short_description = _('Is it a mouse?')

आलसी अनुवाद की वस्तुओं के साथ काम करना

एक gettext_lazy() कॉल के परिणाम का उपयोग किया जा सकता है जहाँ भी आप अन्य Django कोड में एक स्ट्रिंग (एक str ऑब्जेक्ट) का उपयोग करेंगे, लेकिन यह मनमाने ढंग से पायथन कोड के साथ काम नहीं कर सकता है। उदाहरण के लिए, निम्नलिखित काम नहीं करेगा क्योंकि requests लाइब्रेरी gettext_lazy ऑब्जेक्ट्स को हैंडल नहीं gettext_lazy है:

body = gettext_lazy("I \u2764 Django")  # (unicode :heart:)
requests.post('https://example.com/send', data={'body': body})

आप गैर-Django कोड को पास करने से पहले टेक्स्ट स्ट्रिंग्स को gettext_lazy() ऑब्जेक्ट्स कास्टिंग करके ऐसी समस्याओं से बच सकते हैं:

requests.post('https://example.com/send', data={'body': str(body)})

यदि आप लंबे gettext_lazy नाम को पसंद नहीं करते हैं, तो आप इसे _ (अंडरस्कोर) के रूप में बदल सकते हैं, जैसे:

from django.db import models
from django.utils.translation import gettext_lazy as _

class MyThing(models.Model):
    name = models.CharField(help_text=_('This is the help text'))

मॉडल और उपयोगिता कार्यों में तार को चिह्नित करने के लिए gettext_lazy() और ngettext_lazy() का उपयोग करना एक सामान्य ऑपरेशन है। जब आप इन वस्तुओं के साथ अपने कोड में कहीं और काम कर रहे हों, तो आपको यह सुनिश्चित करना चाहिए कि आप गलती से उन्हें तार में परिवर्तित न करें, क्योंकि उन्हें यथासंभव देर से परिवर्तित किया जाना चाहिए (ताकि सही स्थान प्रभावी हो)। यह अगले वर्णित सहायक समारोह के उपयोग की आवश्यकता है।

आलसी अनुवाद और बहुवचन

बहुवचन स्ट्रिंग ( [u]n[p]gettext_lazy ) के लिए आलसी अनुवाद का उपयोग करते समय, आप आमतौर पर स्ट्रिंग परिभाषा के समय number तर्क नहीं जानते हैं। इसलिए, आप पूर्णांक के बजाय number तर्क के रूप में एक प्रमुख नाम पारित करने के लिए अधिकृत हैं। तब स्ट्रिंग इंटरपोलेशन के दौरान उस कुंजी के तहत डिक्शनरी में number देखी जाएगी। यहाँ उदाहरण है:

from django import forms
from django.utils.translation import ngettext_lazy

class MyForm(forms.Form):
    error_message = ngettext_lazy("You only provided %(num)d argument",
        "You only provided %(num)d arguments", 'num')

    def clean(self):
        # ...
        if error:
            raise forms.ValidationError(self.error_message % {'num': number})

यदि स्ट्रिंग में ठीक एक अनाम प्लेसहोल्डर है, तो आप सीधे number तर्क के साथ इंटरपोल कर सकते हैं:

class MyForm(forms.Form):
    error_message = ngettext_lazy(
        "You provided %d argument",
        "You provided %d arguments",
    )

    def clean(self):
        # ...
        if error:
            raise forms.ValidationError(self.error_message % number)

स्वरूपण स्ट्रिंग्स: format_lazy()

पायथन के str.format() पद्धति तब काम नहीं करेगी जब या तो format_string या str.format() किसी भी तर्क में आलसी अनुवाद ऑब्जेक्ट शामिल हैं। इसके बजाय, आप django.utils.text.format_lazy() उपयोग कर सकते हैं, जो एक आलसी वस्तु बनाता है जो str.format() विधि को तभी चलाता है जब परिणाम एक स्ट्रिंग में शामिल होता है। उदाहरण के लिए:

from django.utils.text import format_lazy
from django.utils.translation import gettext_lazy
...
name = gettext_lazy('John Lennon')
instrument = gettext_lazy('guitar')
result = format_lazy('{name}: {instrument}', name=name, instrument=instrument)

इस स्थिति में, result में आलसी अनुवाद केवल स्ट्रिंग में परिवर्तित हो जाएगा जब result स्वयं एक स्ट्रिंग में उपयोग किया जाता है (आमतौर पर टेम्पलेट रेंडरिंग समय पर)।

विलंबित अनुवादों में आलसी के अन्य उपयोग

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

from django.utils.functional import lazy
from django.utils.safestring import mark_safe
from django.utils.translation import gettext_lazy as _

mark_safe_lazy = lazy(mark_safe, str)

और फिर बाद में:

lazy_string = mark_safe_lazy(_("<p>My <strong>string!</strong></p>"))

भाषाओं के स्थानीय नाम

get_language_info() [source]

get_language_info() फ़ंक्शन भाषाओं के बारे में विस्तृत जानकारी प्रदान करता है:

>>> from django.utils.translation import activate, get_language_info
>>> activate('fr')
>>> li = get_language_info('de')
>>> print(li['name'], li['name_local'], li['name_translated'], li['bidi'])
German Deutsch Allemand False

शब्दकोश के name , name_local और name_translated विशेषताओं में अंग्रेजी में भाषा का नाम, भाषा में और आपकी वर्तमान सक्रिय भाषा में क्रमशः होता है। bidi विशेषता केवल द्वि-दिशात्मक भाषाओं के लिए सत्य है।

भाषा की जानकारी का स्रोत django.conf.locale मॉड्यूल है। इस जानकारी तक समान पहुंच टेम्प्लेट कोड के लिए उपलब्ध है। निचे देखो।

अंतर्राष्ट्रीयकरण: टेम्पलेट कोड में

Django टेम्प्लेट में अनुवाद दो टेम्पलेट टैग और पायथन कोड की तुलना में थोड़ा अलग सिंटैक्स का उपयोग करता है। अपने टेम्प्लेट को इन टैगों तक पहुँच देने के लिए, अपने टेम्पलेट के शीर्ष की ओर {% load i18n %} डालें। सभी टेम्प्लेट टैग के साथ, इस टैग को सभी टेम्प्लेट में लोड करने की आवश्यकता है जो अनुवाद का उपयोग करते हैं, यहां तक ​​कि वे टेम्प्लेट जो अन्य टेम्प्लेट से विस्तारित होते हैं जो पहले ही i18n टैग को लोड कर चुके हैं।

trans टेम्पलेट टैग

{% trans %} टेम्पलेट टैग या तो एक स्थिर स्ट्रिंग (एकल या दोहरे उद्धरणों में संलग्न) या चर सामग्री का अनुवाद करता है:

<title>{% trans "This is the title." %}</title>
<title>{% trans myvar %}</title>

यदि noop विकल्प मौजूद है, तो वैरिएबल लुकअप अभी भी होता है लेकिन अनुवाद छोड़ दिया जाता है। यह तब उपयोगी होता है जब "स्टबिंग आउट" सामग्री को भविष्य में अनुवाद की आवश्यकता होगी:

<title>{% trans "myvar" noop %}</title>

आंतरिक रूप से, इनलाइन अनुवाद एक gettext() कॉल का उपयोग करते हैं।

यदि टेम्प्लेट myvar (ऊपर myvar ) को टैग में पास किया जाता है, तो टैग पहले रन-टाइम पर एक स्ट्रिंग में इस तरह के वेरिएबल को हल करेगा और फिर मैसेज कैटलॉग में उस स्ट्रिंग को देखेगा।

{% trans %} भीतर एक स्ट्रिंग के अंदर एक टेम्प्लेट वेरिएबल को मिक्स करना संभव नहीं है। यदि आपके अनुवादों को चर (प्लेसहोल्डर) के साथ तार की आवश्यकता होती है, तो इसके बजाय blocktrans उपयोग करें।

यदि आप किसी अनुवादित स्ट्रिंग को प्रदर्शित किए बिना उसे पुनः प्राप्त करना चाहते हैं, तो आप निम्न सिंटैक्स का उपयोग कर सकते हैं:

{% trans "This is the title" as the_title %}

<title>{{ the_title }}</title>
<meta name="description" content="{{ the_title }}">

व्यवहार में आप इसका उपयोग एक स्ट्रिंग प्राप्त करने के लिए कर सकते हैं जिसे आप एक टेम्पलेट में कई स्थानों पर उपयोग कर सकते हैं या इसलिए आप आउटपुट को अन्य टेम्पलेट टैग या फ़िल्टर के तर्क के रूप में उपयोग कर सकते हैं:

{% trans "starting point" as start %}
{% trans "end point" as end %}
{% trans "La Grande Boucle" as race %}

<h1>
  <a href="/" title="{% blocktrans %}Back to '{{ race }}' homepage{% endblocktrans %}">{{ race }}</a>
</h1>
<p>
{% for stage in tour_stages %}
    {% cycle start end %}: {{ stage }}{% if forloop.counter|divisibleby:2 %}<br>{% else %}, {% endif %}
{% endfor %}
</p>

{% trans %} context कीवर्ड का उपयोग करके प्रासंगिक मार्कर का भी समर्थन करता है:

{% trans "May" context "month name" %}

blocktrans टेम्पलेट टैग

trans टैग के विपरीत, blocktrans टैग आपको प्लेसहोल्डर्स का उपयोग करके अनुवाद के लिए शाब्दिक और चर सामग्री से युक्त जटिल वाक्यों को चिह्नित करने की अनुमति देता है:

{% blocktrans %}This string will have {{ value }} inside.{% endblocktrans %}

टेम्पलेट अभिव्यक्ति का अनुवाद करने के लिए - कहते हैं, ऑब्जेक्ट विशेषताओं तक पहुँचना या टेम्पलेट फ़िल्टर का उपयोग करना - आपको अनुवाद ब्लॉक के भीतर उपयोग के लिए स्थानीय चर पर अभिव्यक्ति को बांधने की आवश्यकता है। उदाहरण:

{% blocktrans with amount=article.price %}
That will cost $ {{ amount }}.
{% endblocktrans %}

{% blocktrans with myvar=value|filter %}
This will have {{ myvar }} inside.
{% endblocktrans %}

आप एक ही blocktrans टैग के अंदर कई भावों का उपयोग कर सकते हैं:

{% blocktrans with book_t=book|title author_t=author|title %}
This is {{ book_t }} by {{ author_t }}
{% endblocktrans %}

ध्यान दें

पिछले अधिक वर्बोज़ प्रारूप का अभी भी समर्थन किया गया है: {% blocktrans with book|title as book_t and author|title as author_t %}

अन्य ब्लॉक टैग (उदाहरण के लिए {% for %} या {% if %} ) को blocktrans टैग के अंदर अनुमति नहीं है।

यदि ब्लॉक तर्क में से एक को हल करने में विफल रहता है, तो blocktrans डिफ़ॉल्ट रूप से वर्तमान में सक्रिय भाषा को अस्थायी रूप से deactivate_all() साथ deactivate_all() फ़ंक्शन के साथ।

यह टैग बहुवचन के लिए भी प्रदान करता है। इसके प्रयेाग के लिए:

  • नाम count साथ एक काउंटर मान निर्दिष्ट और बाँधें। यह मान सही बहुवचन रूप का उपयोग करने वाला होगा।
  • {% blocktrans %} भीतर {% plural %} टैग और {% endblocktrans %} टैग के साथ उन्हें अलग करने वाले एकवचन और बहुवचन दोनों रूपों को निर्दिष्ट करें।

एक उदाहरण:

{% blocktrans count counter=list|length %}
There is only one {{ name }} object.
{% plural %}
There are {{ counter }} {{ name }} objects.
{% endblocktrans %}

एक और अधिक जटिल उदाहरण:

{% blocktrans with amount=article.price count years=i.length %}
That will cost $ {{ amount }} per year.
{% plural %}
That will cost $ {{ amount }} per {{ years }} years.
{% endblocktrans %}

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

उल्टे URL लुकअप को blocktrans भीतर नहीं किया जा सकता है और इसे पहले ही प्राप्त (और संग्रहीत) किया जाना चाहिए:

{% url 'path.to.view' arg arg2 as the_url %}
{% blocktrans %}
This is a URL: {{ the_url }}
{% endblocktrans %}

यदि आप किसी अनुवादित स्ट्रिंग को प्रदर्शित किए बिना उसे पुनः प्राप्त करना चाहते हैं, तो आप निम्न सिंटैक्स का उपयोग कर सकते हैं:

{% blocktrans asvar the_title %}The title is {{ title }}.{% endblocktrans %}
<title>{{ the_title }}</title>
<meta name="description" content="{{ the_title }}">

व्यवहार में आप इसका उपयोग एक स्ट्रिंग प्राप्त करने के लिए करेंगे जिसका उपयोग आप एक टेम्पलेट में कई स्थानों पर कर सकते हैं या इसलिए आप आउटपुट को अन्य टेम्पलेट टैग या फ़िल्टर के लिए तर्क के रूप में उपयोग कर सकते हैं।

{% blocktrans %} भी context कीवर्ड का उपयोग करके प्रासंगिक मार्करों का समर्थन करता है:

{% blocktrans with name=user.username context "greeting" %}Hi {{ name }}{% endblocktrans %}

एक अन्य विशेषता {% blocktrans %} का समर्थन trimmed विकल्प है। यह विकल्प नए वर्णों को शुरुआत और {% blocktrans %} टैग की सामग्री के अंत से हटा देगा, किसी भी {% blocktrans %} को एक पंक्ति के आरंभ और अंत में बदल देगा और सभी वर्णों को अलग करने के लिए एक अंतरिक्ष वर्ण का उपयोग करके एक में विलय कर देगा। यह {% blocktrans %} टैग की सामग्री को इंडेंट करने के लिए काफी उपयोगी है, क्योंकि इंडेंटेशन वर्ण पीओ फ़ाइल में संबंधित प्रविष्टि में समाप्त होते हैं, जिससे अनुवाद प्रक्रिया आसान हो जाती है।

उदाहरण के लिए, निम्न {% blocktrans %} टैग:

{% blocktrans trimmed %}
  First sentence.
  Second paragraph.
{% endblocktrans %}

परिणाम में प्रवेश होगा "First sentence. Second paragraph." यदि trimmed विकल्प को निर्दिष्ट नहीं किया गया था, तो PO फाइल में, "\n First sentence.\n Second sentence.\n" में।

स्ट्रिंग शाब्दिक टैग और फ़िल्टर को पारित कर दिया

आप परिचित _() सिंटैक्स का उपयोग करके टैग और फ़िल्टर के तर्कों के रूप में पारित स्ट्रिंग शाब्दिकों का अनुवाद कर सकते हैं:

{% some_tag _("Page not found") value|yesno:_("yes,no") %}

इस मामले में, टैग और फ़िल्टर दोनों अनुवादित स्ट्रिंग देखेंगे, इसलिए उन्हें अनुवादों के बारे में पता होने की आवश्यकता नहीं है।

ध्यान दें

इस उदाहरण में, अनुवाद बुनियादी ढांचे को स्ट्रिंग "yes,no" , व्यक्तिगत स्ट्रिंग "yes" और "no" । अनुवादित स्ट्रिंग में कॉमा को समाहित करने की आवश्यकता होगी ताकि फ़िल्टर पार्सिंग कोड जानता हो कि कैसे तर्कों को विभाजित किया जाए। उदाहरण के लिए, एक जर्मन अनुवादक स्ट्रिंग को "yes,no" रूप में "ja,nein" (अल्पविराम को बरकरार रखते हुए) का अनुवाद कर सकता है।

टेम्प्लेट में अनुवादक के लिए टिप्पणियाँ

पाइथन कोड के साथ की तरह, अनुवादकों के लिए ये नोट्स टिप्पणियों का उपयोग करके निर्दिष्ट किए जा सकते हैं, या तो comment टैग के साथ:

{% comment %}Translators: View verb{% endcomment %}
{% trans "View" %}

{% comment %}Translators: Short intro blurb{% endcomment %}
<p>{% blocktrans %}A multiline translatable
literal.{% endblocktrans %}</p>

या {##} एक-लाइन टिप्पणी के साथ निर्माण :

{# Translators: Label of a button that triggers search #}
<button type="submit">{% trans "Go" %}</button>

{# Translators: This is a text of the base template #}
{% blocktrans %}Ambiguous translatable block of text{% endblocktrans %}

ध्यान दें

पूर्णता के लिए, ये परिणामी .po फ़ाइल के संगत अंश हैं:

#. Translators: View verb
# path/to/template/file.html:10
msgid "View"
msgstr ""

#. Translators: Short intro blurb
# path/to/template/file.html:13
msgid ""
"A multiline translatable"
"literal."
msgstr ""

# ...

#. Translators: Label of a button that triggers search
# path/to/template/file.html:100
msgid "Go"
msgstr ""

#. Translators: This is a text of the base template
# path/to/template/file.html:103
msgid "Ambiguous translatable block of text"
msgstr ""

भाषा को टेम्प्लेट में बदलना

यदि आप किसी टेम्प्लेट के भीतर भाषा का चयन करना चाहते हैं, तो आप language टेम्प्लेट टैग का उपयोग कर सकते हैं:

{% load i18n %}

{% get_current_language as LANGUAGE_CODE %}
<!-- Current language: {{ LANGUAGE_CODE }} -->
<p>{% trans "Welcome to our page" %}</p>

{% language 'en' %}
    {% get_current_language as LANGUAGE_CODE %}
    <!-- Current language: {{ LANGUAGE_CODE }} -->
    <p>{% trans "Welcome to our page" %}</p>
{% endlanguage %}

जबकि "हमारे पृष्ठ में आपका स्वागत है" की पहली घटना वर्तमान भाषा का उपयोग करती है, दूसरी हमेशा अंग्रेजी में होगी।

अन्य टैग

इन टैगों के लिए {% load i18n %} भी आवश्यकता होती है।

get_available_languages

{% get_available_languages as LANGUAGES %} tuples की एक सूची देता है जिसमें पहला तत्व भाषा कोड होता है और दूसरा भाषा का नाम (वर्तमान में सक्रिय लोकेल में अनुवादित) होता है।

get_current_language

{% get_current_language as LANGUAGE_CODE %} एक स्ट्रिंग के रूप में वर्तमान उपयोगकर्ता की पसंदीदा भाषा देता है। उदाहरण: en-us देखें कि कैसे Django भाषा को प्राथमिकता देता है

get_current_language_bidi

{% get_current_language_bidi as LANGUAGE_BIDI %} वर्तमान स्थान की दिशा देता है। यदि True , तो यह एक दाएं-से-बाएं भाषा है, जैसे हिब्रू, अरबी। यदि False यह बाएं से दाएं भाषा है, जैसे अंग्रेजी, फ्रेंच, जर्मन, आदि।

i18n संदर्भ प्रोसेसर

यदि आप django.template.context_processors.i18n संदर्भ प्रोसेसर को सक्षम करते हैं, तो प्रत्येक RequestContext ऊपर बताए अनुसार LANGUAGES , LANGUAGE_CODE और LANGUAGE_BIDI तक पहुंच होगी।

get_language_info

आप उपलब्ध टेम्प्लेट टैग और फ़िल्टर का उपयोग करके किसी भी उपलब्ध भाषा के बारे में जानकारी प्राप्त कर सकते हैं। किसी एक भाषा के बारे में जानकारी प्राप्त करने के लिए, {% get_language_info %} टैग का उपयोग करें:

{% get_language_info for LANGUAGE_CODE as lang %}
{% get_language_info for "pl" as lang %}

तब आप जानकारी तक पहुँच सकते हैं:

Language code: {{ lang.code }}<br>
Name of language: {{ lang.name_local }}<br>
Name in English: {{ lang.name }}<br>
Bi-directional: {{ lang.bidi }}
Name in the active language: {{ lang.name_translated }}

get_language_info_list

आप भाषाओं की सूची के लिए जानकारी प्राप्त करने के लिए {% get_language_info_list %} टेम्पलेट टैग का उपयोग भी कर सकते हैं (उदाहरण के लिए सक्रिय भाषाओं के रूप में निर्दिष्ट)। {% get_language_info_list %} का उपयोग करके भाषा चयनकर्ता को प्रदर्शित करने के तरीके के उदाहरण के लिए set_language पुनर्निर्देशन के बारे में अनुभाग देखें।

LANGUAGES शैली की सूची के अलावा, {% get_language_info_list %} भाषा कोड की सरल सूचियों का समर्थन करता है। यदि आप अपने विचार में ऐसा करते हैं:

context = {'available_languages': ['en', 'es', 'fr']}
return render(request, 'mytemplate.html', context)

आप टेम्प्लेट में उन भाषाओं पर पुनरावृति कर सकते हैं:

{% get_language_info_list for available_languages as langs %}
{% for lang in langs %} ... {% endfor %}

खाका फिल्टर

सुविधा के लिए सरल फिल्टर भी उपलब्ध हैं:

  • {{ LANGUAGE_CODE|language_name }} ("जर्मन")
  • {{ LANGUAGE_CODE|language_name_local }} ("Deutsch")
  • {{ LANGUAGE_CODE|language_bidi }} (गलत)
  • {{ LANGUAGE_CODE|language_name_translated }} ("německy", जब सक्रिय भाषा चेक है)

अंतर्राष्ट्रीयकरण: जावास्क्रिप्ट कोड में

जावास्क्रिप्ट में अनुवाद जोड़ने से कुछ समस्याएँ होती हैं:

  • जावास्क्रिप्ट कोड के पास gettext कार्यान्वयन तक पहुंच नहीं है।
  • जावास्क्रिप्ट कोड में .po या .mo फाइलों तक पहुंच नहीं है; वे सर्वर द्वारा दिया जाना चाहिए।
  • जावास्क्रिप्ट के लिए अनुवाद कैटलॉग को यथासंभव छोटा रखा जाना चाहिए।

Django इन समस्याओं के लिए एक एकीकृत समाधान प्रदान करता है: यह अनुवाद को जावास्क्रिप्ट में उत्तीर्ण करता है, इसलिए आप जावास्क्रिप्ट के भीतर से gettext आदि को कॉल कर सकते हैं।

इन समस्याओं का मुख्य समाधान निम्नलिखित JavaScriptCatalog दृश्य है, जो कार्यों के साथ एक जावास्क्रिप्ट कोड लाइब्रेरी उत्पन्न करता है जो gettext इंटरफ़ेस की नकल करता है, साथ ही अनुवाद स्ट्रिंग की एक सरणी।

JavaScriptCatalog दृश्य

class JavaScriptCatalog [source]

एक दृश्य जो जावास्क्रिप्ट कोड लाइब्रेरी का निर्माण करता है, जो gettext इंटरफेस की नकल करता है, साथ ही अनुवाद स्ट्रिंग की एक सरणी।

गुण

domain

व्यू आउटपुट में जोड़ने के लिए स्ट्रिंग्स युक्त अनुवाद डोमेन। 'djangojs' लिए चूक।

packages

स्थापित अनुप्रयोगों के बीच application names की एक सूची। उन ऐप्स में locale डायरेक्टरी होनी चाहिए। LOCALE_PATHS में पाए जाने वाले सभी कैटलॉग और सभी कैटलॉग (जो हमेशा शामिल होते हैं) को एक कैटलॉग में मिला दिया जाता है। None लिए None चूक, जिसका अर्थ है कि सभी INSTALLED_APPS से उपलब्ध सभी अनुवाद जावास्क्रिप्ट आउटपुट में दिए गए हैं।

डिफ़ॉल्ट मान के साथ उदाहरण :

from django.views.i18n import JavaScriptCatalog

urlpatterns = [
    path('jsi18n/', JavaScriptCatalog.as_view(), name='javascript-catalog'),
]

कस्टम पैकेज के साथ उदाहरण :

urlpatterns = [
    path('jsi18n/myapp/',
         JavaScriptCatalog.as_view(packages=['your.app.label']),
         name='javascript-catalog'),
]

यदि आपकी रूट URLconf i18n_patterns() का उपयोग करता है, तो कैटलॉग के लिए JavaScriptCatalog को भी i18n_patterns() द्वारा सही तरीके से i18n_patterns() किया जाना चाहिए।

i18n_patterns() साथ उदाहरण :

from django.conf.urls.i18n import i18n_patterns

urlpatterns = i18n_patterns(
    path('jsi18n/', JavaScriptCatalog.as_view(), name='javascript-catalog'),
)

अनुवादों की पूर्ववर्ती स्थिति ऐसी है कि packages तर्क में बाद में दिखने वाले packages की शुरुआत की तुलना में अधिक पूर्वता होती है। एक ही शाब्दिक अनुवाद के लिए क्लैशिंग अनुवाद के मामले में यह महत्वपूर्ण है।

यदि आप किसी साइट पर एक से अधिक JavaScriptCatalog दृश्य का उपयोग करते हैं और उनमें से कुछ एक ही तार को परिभाषित करते हैं, तो कैटलॉग के तार जो पिछली बार लोड किए गए थे, पूर्वता लेते हैं।

जावास्क्रिप्ट अनुवाद सूची का उपयोग करना

कैटलॉग का उपयोग करने के लिए, बस गतिशील रूप से उत्पन्न स्क्रिप्ट को इस तरह खींचें:

<script type="text/javascript" src="{% url 'javascript-catalog' %}"></script>

जावास्क्रिप्ट कैटलॉग दृश्य के URL को खोजने के लिए यह रिवर्स URL लुकअप का उपयोग करता है। जब कैटलॉग लोड किया जाता है, तो आपका जावास्क्रिप्ट कोड निम्नलिखित विधियों का उपयोग कर सकता है:

  • gettext
  • ngettext
  • interpolate
  • get_format
  • gettext_noop
  • pgettext
  • npgettext
  • pluralidx

gettext

gettext फ़ंक्शन आपके पायथन कोड के भीतर मानक gettext इंटरफ़ेस के समान व्यवहार करता है:

document.write(gettext('this is to be translated'));

ngettext

ngettext फ़ंक्शन शब्दों और वाक्यांशों को बहुवचन देने के लिए एक इंटरफ़ेस प्रदान करता है:

var object_count = 1 // or 0, or 2, or 3, ...
s = ngettext('literal for the singular case',
        'literal for the plural case', object_count);

interpolate

interpolate फ़ंक्शन गतिशील स्ट्रिंग को पॉप्युलेट करने का समर्थन करता है। प्रक्षेप सिंटैक्स को पाइथन से उधार लिया जाता है, इसलिए interpolate फ़ंक्शन, स्थितीय और नामित प्रक्षेप दोनों का समर्थन करता है:

  • स्थितिगत प्रक्षेप: obj में एक जावास्क्रिप्ट ऐरे ऑब्जेक्ट होता है जिसके तत्व मान तब क्रमिक रूप से उनके संबंधित fmt प्लेसहोल्डर्स में उसी क्रम में प्रक्षेपित होते हैं, जिस क्रम में वे दिखाई देते हैं। उदाहरण के लिए:

    fmts = ngettext('There is %s object. Remaining: %s',
            'There are %s objects. Remaining: %s', 11);
    s = interpolate(fmts, [11, 20]);
    // s is 'There are 11 objects. Remaining: 20'
    
  • नामांकित प्रक्षेप: इस मोड का चयन वैकल्पिक बूलियन named पैरामीटर को true मानकर किया जाता trueobj में एक JavaScript ऑब्जेक्ट या साहचर्य सरणी होती है। उदाहरण के लिए:

    d = {
        count: 10,
        total: 50
    };
    
    fmts = ngettext('Total: %(total)s, there is %(count)s object',
    'there are %(count)s of a total of %(total)s objects', d.count);
    s = interpolate(fmts, d, true);
    

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

get_format

get_format समारोह के लिए कॉन्फ़िगर i18n प्रारूपण सेटिंग की पहुंच है और किसी दिए गए सेटिंग नाम के लिए प्रारूप स्ट्रिंग को पुनः प्राप्त कर सकते हैं:

document.write(get_format('DATE_FORMAT'));
// 'N j, Y'

इसकी निम्न सेटिंग्स तक पहुंच है:

यह पायथन-प्रदान किए गए मानों के साथ स्वरूपण स्थिरता बनाए रखने के लिए उपयोगी है।

gettext_noop

यह gettext फ़ंक्शन का अनुकरण करता है, लेकिन कुछ भी नहीं करता है, जो भी इसे पारित करता है उसे वापस करता है:

document.write(gettext_noop('this will not be translated'));

यह कोड के उन हिस्सों को बाहर निकालने के लिए उपयोगी है जिन्हें भविष्य में अनुवाद की आवश्यकता होगी।

pgettext

यह pgettext फ़ंक्शन पायथन वेरिएंट की तरह व्यवहार करता है ( django.utils.translation.pgettext() ), प्रासंगिक रूप से अनुवादित शब्द प्रदान करता है:

document.write(pgettext('month name', 'May'));

npgettext

npgettext समारोह भी अजगर संस्करण (तरह बर्ताव करता है django.utils.translation.npgettext() ), एक प्रदान बहुवचन प्रासंगिक रूप से अनुवादित शब्द:

document.write(npgettext('group', 'party', 1));
// party
document.write(npgettext('group', 'party', 2));
// parties

pluralidx

pluralidx कार्य करने के लिए एक समान तरीके से काम करता है pluralize टेम्पलेट फिल्टर, यह तय करना दिए गए count एक शब्द या नहीं के बहुवचन रूप का उपयोग करना चाहिए:

document.write(pluralidx(0));
// true
document.write(pluralidx(1));
// false
document.write(pluralidx(2));
// true

सबसे सरल मामले में, यदि कोई कस्टम बहुवचन की आवश्यकता नहीं है, तो यह false पूर्णांक 1 और true अन्य सभी संख्याओं के लिए वापस आ जाता है।

हालाँकि, बहुवचन सभी भाषाओं में सरल नहीं है। यदि भाषा बहुवचन का समर्थन नहीं करती है, तो एक खाली मान प्रदान किया जाता है।

इसके अतिरिक्त, अगर बहुवचन के आसपास जटिल नियम हैं, तो कैटलॉग दृश्य एक सशर्त अभिव्यक्ति प्रदान करेगा। यह या तो एक true (बहुवचन करना चाहिए) या false ( बहुवचन नहीं करना चाहिए ) मूल्य का मूल्यांकन करेगा।

JSONCatalog राय

class JSONCatalog [source]

अनुवादों को संभालने के लिए किसी अन्य क्लाइंट-साइड लाइब्रेरी का उपयोग करने के लिए, आप JSONCatalog दृश्य का लाभ उठाना चाहते हैं। यह JavaScriptCatalog एक JSON प्रतिक्रिया देता है, लेकिन इसके समान है ।

JavaScriptCatalog संभावित मूल्यों domain और packages विशेषताओं के उपयोग के बारे में जानने के लिए दस्तावेज़ देखें ।

प्रतिक्रिया स्वरूप इस प्रकार है:

{
    "catalog": {
        # Translations catalog
    },
    "formats": {
        # Language formats for date, time, etc.
    },
    "plural": "..."  # Expression for plural forms, or null.
}

प्रदर्शन पर ध्यान दें

विभिन्न जावास्क्रिप्ट / JSON i18n विचार .mo हर अनुरोध पर फ़ाइलों से कैटलॉग उत्पन्न करते हैं। चूंकि इसका आउटपुट स्थिर है, कम से कम किसी साइट के दिए गए संस्करण के लिए, यह कैशिंग के लिए एक अच्छा उम्मीदवार है।

सर्वर-साइड कैशिंग CPU लोड को कम करेगा। इसे cache_page() डेकोरेटर के साथ आसानी से लागू किया जाता है । जब आपके अनुवाद बदलते हैं, तो कैश अमान्यकरण को ट्रिगर करने के लिए, एक संस्करण-निर्भर कुंजी उपसर्ग प्रदान करें, जैसा कि नीचे दिए गए उदाहरण में दिखाया गया है, या संस्करण-निर्भर URL पर दृश्य मैप करें:

from django.views.decorators.cache import cache_page
from django.views.i18n import JavaScriptCatalog

# The value returned by get_version() must change when translations change.
urlpatterns = [
    path('jsi18n/',
         cache_page(86400, key_prefix='js18n-%s' % get_version())(JavaScriptCatalog.as_view()),
         name='javascript-catalog'),
]

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

from django.utils import timezone
from django.views.decorators.http import last_modified
from django.views.i18n import JavaScriptCatalog

last_modified_date = timezone.now()

urlpatterns = [
    path('jsi18n/',
         last_modified(lambda req, **kw: last_modified_date)(JavaScriptCatalog.as_view()),
         name='javascript-catalog'),
]

आप अपनी तैनाती प्रक्रिया के हिस्से के रूप में जावास्क्रिप्ट कैटलॉग को प्री-जेनरेट भी कर सकते हैं और इसे स्टैटिक फाइल के रूप में सर्व कर सकते हैं। यह मौलिक तकनीक django-statici18n में कार्यान्वित की गई है ।

अंतर्राष्ट्रीयकरण: URL पैटर्न में

Django URL पैटर्न का अंतर्राष्ट्रीयकरण करने के लिए दो तंत्र प्रदान करता है:

  • django.middleware.locale.LocaleMiddleware अनुरोधित URL से सक्रिय होने के लिए भाषा का पता लगाने के लिए URL पैटर्न के मूल में भाषा उपसर्ग जोड़ना ।
  • gettext_lazy() फ़ंक्शन के माध्यम से URL प्रतिमान खुद को अनुवाद योग्य बनाना ।

चेतावनी

इन विशेषताओं में से किसी एक का उपयोग करने के लिए आवश्यक है कि प्रत्येक अनुरोध के लिए एक सक्रिय भाषा सेट की जाए; दूसरे शब्दों में, आपको django.middleware.locale.LocaleMiddleware अपनी MIDDLEWARE सेटिंग में होना चाहिए।

URL पैटर्न में भाषा उपसर्ग

i18n_patterns(*urls, prefix_default_language=True) [source]

इस फ़ंक्शन का उपयोग रूट URLconf में किया जा सकता है और Django स्वचालित रूप से वर्तमान सक्रिय भाषा कोड को सभी URL पैटर्नों में परिभाषित करेगा i18n_patterns()

डिफ़ॉल्ट भाषा से उपसर्ग को हटाने के prefix_default_language लिए सेटिंग False ( LANGUAGE_CODE )। मौजूदा साइट में अनुवाद जोड़ते समय यह उपयोगी हो सकता है ताकि वर्तमान URL परिवर्तित न हों।

उदाहरण URL पैटर्न:

from django.conf.urls.i18n import i18n_patterns
from django.urls import include, url

from about import views as about_views
from news import views as news_views
from sitemap.views import sitemap

urlpatterns = [
    path('sitemap.xml', sitemap, name='sitemap-xml'),
]

news_patterns = ([
    path('', news_views.index, name='index'),
    path('category/<slug:slug>/', news_views.category, name='category'),
    path('<slug:slug>/', news_views.details, name='detail'),
], 'news')

urlpatterns += i18n_patterns(
    path('about/', about_views.main, name='about'),
    path('news/', include(news_patterns, namespace='news')),
)

इन URL पैटर्न को परिभाषित करने के बाद, Django स्वचालित रूप से i18n_patterns फ़ंक्शन द्वारा जोड़े गए URL पैटर्न में भाषा उपसर्ग जोड़ देगा । उदाहरण:

>>> from django.urls import reverse
>>> from django.utils.translation import activate

>>> activate('en')
>>> reverse('sitemap-xml')
'/sitemap.xml'
>>> reverse('news:index')
'/en/news/'

>>> activate('nl')
>>> reverse('news:detail', kwargs={'slug': 'news-slug'})
'/nl/news/news-slug/'

साथ prefix_default_language=False और LANGUAGE_CODE='en' , यूआरएल हो जाएगा:

>>> activate('en')
>>> reverse('news:index')
'/news/'

>>> activate('nl')
>>> reverse('news:index')
'/nl/news/'

चेतावनी

i18n_patterns() केवल रूट URLconf में अनुमति है। एक शामिल URLconf के भीतर इसका उपयोग एक ImproperlyConfigured अपवाद फेंक देंगे ।

चेतावनी

सुनिश्चित करें कि आपके पास गैर-उपसर्ग URL प्रतिमान नहीं हैं जो स्वचालित रूप से जोड़े गए भाषा उपसर्ग से टकरा सकते हैं।

URL पैटर्न का अनुवाद करना

gettext_lazy() फ़ंक्शन का उपयोग करके URL पैटर्न को अनुवाद योग्य भी चिह्नित किया जा सकता है। उदाहरण:

from django.conf.urls.i18n import i18n_patterns
from django.urls import include, path
from django.utils.translation import gettext_lazy as _

from about import views as about_views
from news import views as news_views
from sitemaps.views import sitemap

urlpatterns = [
    path('sitemap.xml', sitemap, name='sitemap-xml'),
]

news_patterns = ([
    path('', news_views.index, name='index'),
    path(_('category/<slug:slug>/'), news_views.category, name='category'),
    path('<slug:slug>/', news_views.details, name='detail'),
], 'news')

urlpatterns += i18n_patterns(
    path(_('about/'), about_views.main, name='about'),
    path(_('news/'), include(news_patterns, namespace='news')),
)

आपके द्वारा अनुवाद तैयार करने के बाद, reverse() फ़ंक्शन सक्रिय भाषा में URL लौटा देगा। उदाहरण:

>>> from django.urls import reverse
>>> from django.utils.translation import activate

>>> activate('en')
>>> reverse('news:category', kwargs={'slug': 'recent'})
'/en/news/category/recent/'

>>> activate('nl')
>>> reverse('news:category', kwargs={'slug': 'recent'})
'/nl/nieuws/categorie/recent/'

चेतावनी

ज्यादातर मामलों में, अनुवादित URL का उपयोग करना सबसे अच्छा है केवल एक भाषा कोड पैटर्न के उपसर्ग ब्लॉक (उपयोग i18n_patterns() ) के भीतर, इस संभावना से बचने के लिए कि लापरवाह अनुवादित URL गैर-अनुवादित URL पैटर्न के साथ टकराव का कारण बनता है।

टेंपरेचर में उलटफेर

यदि स्थानीयकृत URL टेम्प्लेट में उलट जाते हैं तो वे हमेशा वर्तमान भाषा का उपयोग करते हैं। किसी अन्य भाषा में URL से लिंक करने के लिए language टेम्पलेट टैग का उपयोग करें । यह दिए गए टेम्पलेट अनुभाग में दी गई भाषा को सक्षम करता है:

{% load i18n %}

{% get_available_languages as languages %}

{% trans "View this category in:" %}
{% for lang_code, lang_name in languages %}
    {% language lang_code %}
    <a href="{% url 'category' slug=category.slug %}">{{ lang_name }}</a>
    {% endlanguage %}
{% endfor %}

language टैग केवल तर्क के रूप में भाषा कोड की उम्मीद है।

स्थानीयकरण: भाषा फ़ाइलों का निर्माण कैसे करें

एक बार एक आवेदन के स्ट्रिंग शाब्दिक बाद के अनुवाद के लिए टैग किया गया है, अनुवाद खुद को लिखा जाना चाहिए (या प्राप्त)। यहाँ है कि कैसे काम करता है।

संदेश फ़ाइलें

पहला कदम एक नई भाषा के लिए एक संदेश फ़ाइल बनाना है । एक संदेश फ़ाइल एक सादी-पाठ फ़ाइल है, जो एकल भाषा का प्रतिनिधित्व करती है, जिसमें सभी उपलब्ध अनुवाद स्ट्रिंग होते हैं और उन्हें दी गई भाषा में कैसे प्रस्तुत किया जाना चाहिए। संदेश फ़ाइलों में एक .po फ़ाइल एक्सटेंशन होता है।

Django एक उपकरण के साथ आता है makemessages , जो इन फ़ाइलों के निर्माण और रखरखाव को स्वचालित करता है।

गेटटेक्स्ट यूटिलिटीज

makemessages आदेश (और compilemessages बाद में चर्चा की) GNU gettext टूलसेट से आदेश का उपयोग करें: xgettext , msgfmt , msgmerge और msguniq

gettext समर्थित उपयोगिताओं का न्यूनतम संस्करण 0.15 है।

संदेश फ़ाइल बनाने या अपडेट करने के लिए, यह कमांड चलाएँ:

django-admin makemessages -l de

... उस संदेश फ़ाइल de का स्थानीय नाम कहां है जिसे आप बनाना चाहते हैं। उदाहरण के लिए, pt_BR ब्राज़ीलियाई पुर्तगाली के लिए, de_AT ऑस्ट्रियाई जर्मन के लिए या id इंडोनेशियाई के लिए।

स्क्रिप्ट को दो स्थानों में से एक से चलाया जाना चाहिए:

  • आपके Django प्रोजेक्ट की मूल निर्देशिका (जिसमें एक है manage.py )।
  • अपने Django एप्लिकेशन में से एक की रूट निर्देशिका।

स्क्रिप्ट आपके प्रोजेक्ट सोर्स ट्री या आपके एप्लिकेशन सोर्स ट्री पर चलती है और ट्रांसलेशन के लिए चिह्नित सभी स्ट्रिंग्स को बाहर निकालती है (देखें कि कैसे Django ट्रांसलेशन LOCALE_PATHS को ठीक करता है और सुनिश्चित करें कि वह सही तरीके से कॉन्फ़िगर किया गया है)। यह निर्देशिका में एक संदेश फ़ाइल बनाता है (या अपडेट करता है) locale/LANG/LC_MESSAGES । में de उदाहरण के लिए, फ़ाइल हो जाएगा locale/de/LC_MESSAGES/django.po

जब आप makemessages अपनी परियोजना की मूल निर्देशिका से चलते हैं , तो निकाले गए तार स्वचालित रूप से उचित संदेश फ़ाइलों में वितरित हो जाएंगे। यानि किसी locale डायरेक्टरी वाले ऐप की फाइल से निकाला गया एक स्ट्रिंग उस डायरेक्टरी के तहत एक मैसेज फाइल में जाएगा। बिना किसी locale डायरेक्टरी के किसी ऐप की फाइल से निकाला गया स्ट्रिंग या तो पहले लिस्ट की गई डायरेक्टरी के तहत मैसेज फाइल में LOCALE_PATHS जाएगा या LOCALE_PATHS खाली होने पर एरर जेनरेट करेगा ।

डिफ़ॉल्ट रूप से makemessages है कि हर फ़ाइल की जांच करता है .html , .txt या .py फाइल एक्सटेंशन। यदि आप उस डिफ़ॉल्ट को ओवरराइड करना चाहते हैं, तो जांच के लिए फ़ाइल एक्सटेंशन को निर्दिष्ट करने के लिए --extension या -e विकल्प का उपयोग करें:

django-admin makemessages -l de -e txt

कॉमा और / या उपयोग -e या --extension कई बार के साथ कई एक्सटेंशन अलग करें :

django-admin makemessages -l de -e html,txt -e xml

चेतावनी

जब जावास्क्रिप्ट स्रोत कोड से संदेश फ़ाइलें बनाने आप विशेष उपयोग करने की आवश्यकता djangojs डोमेन, नहीं -e js

Jinja2 टेम्पलेट्स का उपयोग?

makemessages Jinja2 टेम्पलेट्स के वाक्यविन्यास को नहीं समझता है। Jinja2 टेम्प्लेट वाले प्रोजेक्ट से स्ट्रिंग्स निकालने के लिए, इसके बजाय Babel से मैसेज एक्सट्रैक्टिंग का उपयोग करें । Babel

यहाँ एक उदाहरण babel.cfg विन्यास फाइल है:

# Extraction from Python source files
[python: **.py]

# Extraction from Jinja2 templates
[jinja2: **.jinja]
extensions = jinja2.ext.with_

सुनिश्चित करें कि आप अपने द्वारा उपयोग किए जा रहे सभी एक्सटेंशनों को सूचीबद्ध करते हैं! अन्यथा बैबल इन एक्सटेंशन द्वारा परिभाषित टैग को नहीं पहचान पाएगा और पूरी तरह से युक्त जिनजा 2 टेम्प्लेट को अनदेखा कर देगा।

बैबेल makemessages इसे समान सुविधाएँ प्रदान करता है , इसे सामान्य रूप से बदल सकता है, और यह निर्भर नहीं करता है gettext । अधिक जानकारी के लिए, संदेश कैटलॉग के साथ काम करने के बारे में इसके प्रलेखन को पढ़ें ।

कोई गेटटेक्स्ट नहीं?

यदि आपके पास gettext उपयोगिताओं को स्थापित नहीं किया गया है, makemessages तो खाली फाइलें बनाएंगे। यदि ऐसा है, या तो gettext उपयोगिताओं को स्थापित करें या locale/en/LC_MESSAGES/django.po यदि उपलब्ध हो तो अंग्रेजी संदेश फ़ाइल ( ) को कॉपी करें और इसे शुरुआती बिंदु के रूप में उपयोग करें; यह सिर्फ एक खाली अनुवाद फ़ाइल है।

विंडोज पर काम कर रहे हैं?

यदि आप विंडोज का उपयोग कर रहे हैं और जीएनयू गेटटेक्स्ट उपयोगिताओं को स्थापित करने की आवश्यकता है तो makemessages काम करता है, अधिक जानकारी के लिए विंडोज पर गेटटेक्स्ट देखें।

.po फ़ाइलों का प्रारूप सीधा है। प्रत्येक .po फ़ाइल में मेटाडेटा का एक छोटा सा हिस्सा होता है, जैसे अनुवाद अनुचर की संपर्क जानकारी, लेकिन फ़ाइल का थोक संदेशों की एक सूची है - अनुवाद स्ट्रिंग के बीच सरल मैपिंग और विशेष भाषा के लिए वास्तविक अनुवादित पाठ।

उदाहरण के लिए, यदि आपके Django ऐप में पाठ के लिए अनुवाद स्ट्रिंग है "Welcome to my site." , जैसे:

_("Welcome to my site.")

… तो makemessages एक .po फ़ाइल बनाया जाएगा जिसमें निम्नलिखित स्निपेट होगा - एक संदेश:

#: path/to/python/module.py:23
msgid "Welcome to my site."
msgstr ""

एक त्वरित स्पष्टीकरण:

  • msgid अनुवाद स्ट्रिंग है, जो स्रोत में दिखाई देती है। इसे मत बदलो।
  • msgstr वह जगह है जहाँ आप भाषा-विशिष्ट अनुवाद करते हैं। यह खाली होना शुरू हो जाता है, इसलिए इसे बदलना आपकी जिम्मेदारी है। सुनिश्चित करें कि आप अपने अनुवाद के आसपास उद्धरण रखते हैं।
  • एक सुविधा के रूप में, प्रत्येक संदेश में एक टिप्पणी लाइन के रूप में शामिल है, # जो msgid लाइन के ऊपर और उसके ऊपर स्थित है , फ़ाइल नाम और लाइन संख्या जिसमें से अनुवाद स्ट्रिंग को चमकाया गया था।

लंबे संदेश एक विशेष मामला है। वहाँ, msgstr (या msgid ) के बाद सीधे पहली स्ट्रिंग एक खाली स्ट्रिंग है। फिर सामग्री को अगली कुछ पंक्तियों में एक स्ट्रिंग प्रति पंक्ति के रूप में लिखा जाएगा। उन तारों को सीधे समतल किया जाता है। तारों के भीतर रिक्त स्थान को मत भूलना; अन्यथा, वे व्हॉट्सएप के बिना एक साथ निपटेंगे!

अपने आकर्षण का मन

जिस तरह से gettext उपकरण आंतरिक रूप से काम करते हैं और क्योंकि हम गैर-एएससीआईआई स्रोत स्ट्रिंग्स को Django के कोर और आपके अनुप्रयोगों में अनुमति देना चाहते हैं, आपको अपने PO फाइलों के लिए एन्कोडिंग के रूप में UTF-8 का उपयोग करना होगा (जब पीओ फाइलें बनती हैं)। इसका मतलब है कि हर कोई एक ही एन्कोडिंग का उपयोग कर रहा होगा, जो कि महत्वपूर्ण है जब Django PO फ़ाइलों को संसाधित करता है।

नए अनुवाद स्ट्रिंग्स के लिए सभी स्रोत कोड और टेम्प्लेट पुन: जांचने के लिए और सभी भाषाओं के लिए सभी संदेश फ़ाइलों को अपडेट करें , इसे चलाएं:

django-admin makemessages -a

संदेश फ़ाइलों का संकलन

जब आप अपनी संदेश फ़ाइल बनाते हैं - और हर बार जब आप उसमें परिवर्तन करते हैं - तो आपको इसे उपयोग करने के लिए और अधिक कुशल रूप में संकलित करना होगा gettext । इस django-admin compilemessages उपयोगिता के साथ करो ।

यह उपकरण सभी उपलब्ध .po फाइलों पर चलता है और फाइलें बनाता .mo है, जो कि उपयोग के लिए अनुकूलित बाइनरी फाइलें हैं gettext । जिस निर्देशिका से आप भागे थे makemessages , उसी django-admin compilemessages तरह से चलाएं :

django-admin compilemessages

बस। आपके अनुवाद उपयोग के लिए तैयार हैं।

विंडोज पर काम कर रहे हैं?

यदि आप विंडोज का उपयोग कर रहे हैं और जीएनयू गेटटेक्स्ट उपयोगिताओं को स्थापित करने की आवश्यकता है, तो django-admin compilemessages काम करता है अधिक जानकारी के लिए विंडोज पर गेटटेक्स्ट देखें।

.po फाइलें: एनकोडिंग और बीओएम उपयोग।

Django केवल .po UTF-8 और बिना किसी BOM (बाइट ऑर्डर मार्क) में एनकोड की गई फ़ाइलों का समर्थन करता है, इसलिए यदि आपका टेक्स्ट एडिटर डिफ़ॉल्ट रूप से फाइलों की शुरुआत में ऐसे निशान जोड़ता है, तो आपको इसे पुन: कॉन्फ़िगर करने की आवश्यकता होगी।

समस्या निवारण: प्रतिशत संकेतों के साथ स्ट्रिंग में gettext() गलत तरीके से पता लगाता python-format है

कुछ मामलों में, जैसे कि एक प्रतिशत चिह्न के साथ तार और उसके बाद एक स्थान और एक स्ट्रिंग रूपांतरण प्रकार (जैसे _("10% interest") ), gettext() गलत तरीके से झंडे के साथ तार python-format

यदि आप गलत फ़्लैग किए गए स्ट्रिंग्स के साथ संदेश फ़ाइलों को संकलित करने का प्रयास करते हैं, तो आपको एक त्रुटि संदेश मिलेगा जैसे number of format specifications in 'msgid' and 'msgstr' does not match या 'msgstr' is not a valid Python format string, unlike 'msgid'

इसे हल करने के लिए, आप दूसरे प्रतिशत के संकेत को जोड़कर प्रतिशत संकेतों से बच सकते हैं:

from django.utils.translation import gettext as _
output = _("10%% interest")

या आप उपयोग कर सकते हैं no-python-format ताकि सभी प्रतिशत संकेतों को शाब्दिक रूप में माना जाए:

# xgettext:no-python-format
output = _("10% interest")

जावास्क्रिप्ट स्रोत कोड से संदेश फाइलें बनाना

आप संदेश फ़ाइलों को उसी तरह से बनाते और अपडेट करते हैं जैसे अन्य Django संदेश फ़ाइलें - makemessages उपकरण के साथ । एकमात्र अंतर यह है कि आपको स्पष्ट रूप से यह निर्दिष्ट करने की आवश्यकता है कि गेटटेक्स्ट पार्लेंस को इस मामले में djangojs डोमेन के रूप में क्या जाना जाता है -d djangojs , इस तरह से पैरामीटर प्रदान करके डोमेन :

django-admin makemessages -d djangojs -l de

यह जर्मन के लिए जावास्क्रिप्ट के लिए संदेश फ़ाइल बनाएगा या अपडेट करेगा। संदेश फ़ाइलों को अपडेट करने के बाद, django-admin compilemessages उसी तरह चलाएं जैसे आप सामान्य Django संदेश फ़ाइलों के साथ करते हैं।

gettext विंडोज पर

यह केवल उन लोगों के लिए आवश्यक है जो या तो संदेश आईडी निकालना चाहते हैं या संदेश फ़ाइलों को संकलित करना चाहते हैं ( .po )। अनुवाद कार्य में केवल इस प्रकार की मौजूदा फ़ाइलों को संपादित करना शामिल है, लेकिन यदि आप अपनी स्वयं की संदेश फ़ाइलों को बनाना चाहते हैं, या एक बदली हुई संदेश फ़ाइल का परीक्षण या संकलन करना चाहते हैं, तो एक पूर्व-निर्धारित बाइनरी इंस्टॉलर डाउनलोड करें ।

आप उन gettext बायनेरिज़ का भी उपयोग कर सकते हैं जिन्हें आपने कहीं और प्राप्त किया है, इसलिए जब तक xgettext --version कमांड ठीक से काम नहीं करती है। gettext यदि xgettext --version एक Windows कमांड प्रॉम्प्ट में दर्ज की गई कमांड पॉपअप विंडो का कारण बनती है, तो Django अनुवाद उपयोगिताओं का उपयोग करने का प्रयास न करें "xgettext.exe ने त्रुटियों को उत्पन्न किया है और विंडोज द्वारा बंद कर दिया जाएगा"।

makemessages कमांड को कस्टमाइज करना

यदि आप अतिरिक्त पैरामीटर पास करना चाहते हैं xgettext , तो आपको एक कस्टम makemessages कमांड बनाने और उसकी xgettext_options विशेषता को ओवरराइड करने की आवश्यकता है :

from django.core.management.commands import makemessages

class Command(makemessages.Command):
    xgettext_options = makemessages.Command.xgettext_options + ['--keyword=mytrans']

यदि आपको अधिक लचीलेपन की आवश्यकता है, तो आप अपने कस्टम makemessages कमांड में एक नया तर्क भी जोड़ सकते हैं :

from django.core.management.commands import makemessages

class Command(makemessages.Command):

    def add_arguments(self, parser):
        super().add_arguments(parser)
        parser.add_argument(
            '--extra-keyword',
            dest='xgettext_keywords',
            action='append',
        )

    def handle(self, *args, **options):
        xgettext_keywords = options.pop('xgettext_keywords')
        if xgettext_keywords:
            self.xgettext_options = (
                makemessages.Command.xgettext_options[:] +
                ['--keyword=%s' % kwd for kwd in xgettext_keywords]
            )
        super().handle(*args, **options)

कई तरह का

set_language रीडायरेक्ट दृश्य

set_language(request) [source]

एक सुविधा के रूप में, Django एक दृश्य के साथ आता है django.views.i18n.set_language() , जो उपयोगकर्ता की भाषा की प्राथमिकता निर्धारित करता है और किसी दिए गए URL पर या फिर डिफ़ॉल्ट रूप से पिछले पृष्ठ पर वापस भेज देता है।

अपने URLconf में निम्न पंक्ति जोड़कर इस दृश्य को सक्रिय करें:

path('i18n/', include('django.conf.urls.i18n')),

(ध्यान दें कि यह उदाहरण दृश्य को उपलब्ध कराता है /i18n/setlang/ ।)

चेतावनी

सुनिश्चित करें कि आपने उपरोक्त URL को शामिल नहीं किया है i18n_patterns() - इसे सही ढंग से काम करने के लिए भाषा-स्वतंत्र होने की आवश्यकता है।

अनुरोध में POST एक language पैरामीटर सेट के साथ, दृश्य को विधि के माध्यम से बुलाया जाने की उम्मीद है । यदि सत्र समर्थन सक्षम है, तो दृश्य उपयोगकर्ता के सत्र में भाषा की पसंद को बचाता है। यह django_language डिफ़ॉल्ट रूप से नामित कुकी में भाषा की पसंद को भी बचाता है । ( LANGUAGE_COOKIE_NAME सेटिंग के जरिए नाम बदला जा सकता है ।)

Django 2.1 में परिवर्तित:

पुराने संस्करणों में, कुकी केवल तभी सेट की जाती है जब सत्र समर्थन सक्षम नहीं होता है।

भाषा विकल्प सेट करने के बाद, Django डेटा या डेटा next पैरामीटर की तलाश करता है। यदि ऐसा पाया जाता है और Django इसे एक सुरक्षित URL मानता है (अर्थात यह एक अलग होस्ट को इंगित नहीं करता है और एक सुरक्षित योजना का उपयोग करता है), तो उस URL पर पुनर्निर्देशित किया जाएगा। अन्यथा, Django अनुरोध के स्वरूप के आधार पर, उपयोगकर्ता को URL से हेडर पर पुनर्निर्देशित करने के लिए वापस आ सकता है या यदि यह सेट नहीं है, तो : POST GET Referer /

  • AJAX के अनुरोधों के लिए, यदि next पैरामीटर सेट किया गया था , तो कमबैक किया जाएगा । अन्यथा एक 204 स्थिति कोड (कोई सामग्री नहीं) वापस किया जाएगा।
  • गैर-AJAX अनुरोधों के लिए, फ़ॉलबैक हमेशा प्रदर्शन किया जाएगा।

यहाँ उदाहरण है HTML टेम्पलेट कोड:

{% load i18n %}

<form action="{% url 'set_language' %}" method="post">{% csrf_token %}
    <input name="next" type="hidden" value="{{ redirect_to }}">
    <select name="language">
        {% get_current_language as LANGUAGE_CODE %}
        {% get_available_languages as LANGUAGES %}
        {% get_language_info_list for LANGUAGES as languages %}
        {% for language in languages %}
            <option value="{{ language.code }}"{% if language.code == LANGUAGE_CODE %} selected{% endif %}>
                {{ language.name_local }} ({{ language.code }})
            </option>
        {% endfor %}
    </select>
    <input type="submit" value="Go">
</form>

इस उदाहरण में, Django उस पृष्ठ का URL देखता है जिस पर उपयोगकर्ता को redirect_to संदर्भ चर में पुनर्निर्देशित किया जाएगा ।

सक्रिय भाषा को स्पष्ट रूप से सेट करना

आप वर्तमान सत्र के लिए सक्रिय भाषा को स्पष्ट रूप से सेट करना चाह सकते हैं। उदाहरण के लिए, शायद उपयोगकर्ता की भाषा वरीयता किसी अन्य प्रणाली से पुनर्प्राप्त की जाती है। आपसे पहले ही मिल लिया गया है django.utils.translation.activate() । यह केवल वर्तमान थ्रेड पर लागू होता है। पूरे सत्र के लिए भाषा को बनाए रखने के लिए, सत्र में भी संशोधन LANGUAGE_SESSION_KEY करें:

from django.utils import translation
user_language = 'fr'
translation.activate(user_language)
request.session[translation.LANGUAGE_SESSION_KEY] = user_language

आप आमतौर पर दोनों का उपयोग करना चाहते हैं: django.utils.translation.activate() इस थ्रेड के लिए भाषा बदल जाएगी, और सत्र को संशोधित करने से यह वरीयता भविष्य के अनुरोधों में बनी रहती है।

यदि आप सत्र का उपयोग नहीं कर रहे हैं, तो भाषा कुकी में बनी रहेगी, जिसका नाम कॉन्फ़िगर किया गया है LANGUAGE_COOKIE_NAME । उदाहरण के लिए:

from django.conf import settings
from django.http import HttpResponse
from django.utils import translation
user_language = 'fr'
translation.activate(user_language)
response = HttpResponse(...)
response.set_cookie(settings.LANGUAGE_COOKIE_NAME, user_language)

बाहर के विचारों और टेम्पलेट्स के अनुवाद का उपयोग करना

जबकि Django विचारों और टेम्पलेट्स में उपयोग के लिए i18n टूल का एक समृद्ध सेट प्रदान करता है, यह उपयोग को Django- विशिष्ट कोड तक सीमित नहीं करता है। Django अनुवाद तंत्रों का उपयोग मनमाने ढंग से ग्रंथों को किसी भी भाषा में अनुवाद करने के लिए किया जा सकता है जो Django द्वारा समर्थित है (जब तक एक उपयुक्त अनुवाद कैटलॉग मौजूद है, निश्चित रूप से)। आप एक अनुवाद कैटलॉग को लोड कर सकते हैं, इसे सक्रिय कर सकते हैं और अपनी पसंद की भाषा में पाठ का अनुवाद कर सकते हैं, लेकिन मूल भाषा पर वापस स्विच करना याद रखें, क्योंकि अनुवाद कैटलॉग को प्रति-थ्रेड के आधार पर सक्रिय किया जाता है और इस तरह के बदलाव से एक ही धागे में चल रहे कोड प्रभावित होंगे ।

उदाहरण के लिए:

from django.utils import translation

def welcome_translated(language):
    cur_language = translation.get_language()
    try:
        translation.activate(language)
        text = translation.gettext('welcome')
    finally:
        translation.activate(cur_language)
    return text

इस फंक्शन को वैल्यू के साथ कॉल करना , मिडलवेयर द्वारा निर्धारित और भाषा की परवाह किए बिना 'de' आपको देगा । "Willkommen" LANGUAGE_CODE

विशेष रुचि के कार्य हैं django.utils.translation.get_language() जो वर्तमान थ्रेड में उपयोग की गई भाषा को लौटाते हैं , django.utils.translation.activate() जो वर्तमान थ्रेड के लिए अनुवाद कैटलॉग को सक्रिय django.utils.translation.check_for_language() करता है , और जो यह जांचता है कि क्या दी गई भाषा Django द्वारा समर्थित है।

अधिक संक्षिप्त कोड लिखने में मदद के लिए, एक संदर्भ प्रबंधक भी है जो django.utils.translation.override() प्रवेश पर वर्तमान भाषा को संग्रहीत करता है और इसे बाहर निकलने पर पुनर्स्थापित करता है। इसके साथ, उपरोक्त उदाहरण बन जाता है:

from django.utils import translation

def welcome_translated(language):
    with translation.override(language):
        return translation.gettext('welcome')

कार्यान्वयन नोट

Django अनुवाद की विशेषता

Django की अनुवाद मशीनरी मानक gettext मॉड्यूल का उपयोग करती है जो पायथन के साथ आती है। यदि आप जानते हैं gettext , तो आप इन विशिष्टताओं को नोट कर सकते हैं जिस तरह से Django अनुवाद करता है:

  • स्ट्रिंग डोमेन है django या djangojs । इस स्ट्रिंग डोमेन का उपयोग विभिन्न कार्यक्रमों के बीच अंतर करने के लिए किया जाता है जो अपने डेटा को एक आम संदेश-फ़ाइल लाइब्रेरी (आमतौर पर /usr/share/locale/ ) में संग्रहीत करते हैं । django डोमेन अजगर और टेम्पलेट अनुवाद तार के लिए प्रयोग किया जाता है और वैश्विक अनुवाद कैटलॉग में भरी हुई है। djangojs डोमेन केवल यह सुनिश्चित करें कि उन संभव के रूप में छोटे हैं बनाने के लिए JavaScript अनुवाद कैटलॉग के लिए प्रयोग किया जाता है।
  • Django xgettext अकेले उपयोग नहीं करता है । यह पायथन रैपर को इधर xgettext - उधर करता है msgfmt । यह ज्यादातर सुविधा के लिए है।

कैसे Django भाषा वरीयता पता चलता है

एक बार जब आप अपने अनुवाद तैयार कर लेते हैं - या, यदि आप सिर्फ Django के साथ आने वाले अनुवाद का उपयोग करना चाहते हैं - तो आपको बस अपने ऐप के लिए अनुवाद को सक्रिय करना होगा।

पर्दे के पीछे, Django के पास यह तय करने का एक बहुत ही लचीला मॉडल है कि किस भाषा का उपयोग किया जाना चाहिए - किसी विशेष उपयोगकर्ता या दोनों के लिए स्थापना-चौड़ा।

स्थापना-व्यापी भाषा वरीयता सेट करने के लिए, सेट करें LANGUAGE_CODE । Django इस भाषा को डिफ़ॉल्ट अनुवाद के रूप में उपयोग करता है - अंतिम प्रयास यदि कोई बेहतर मिलान अनुवाद स्थानीय मिडलवेयर द्वारा नियोजित तरीकों में से एक के माध्यम से नहीं मिलता है (नीचे देखें)।

यदि आप चाहते हैं कि सभी को अपनी मूल भाषा के साथ Django चलाने के लिए आपको केवल सेट की गई संदेश फ़ाइलों और उनके संकलित संस्करणों ( ) मौजूद हैं, तो यह LANGUAGE_CODE सुनिश्चित करना होगा । .mo

यदि आप प्रत्येक व्यक्ति को यह बताना चाहते हैं कि उसे कौन सी भाषा पसंद है, तो आपको उसका उपयोग करने की भी आवश्यकता है LocaleMiddlewareLocaleMiddleware अनुरोध से डेटा के आधार पर भाषा चयन सक्षम करता है। यह प्रत्येक उपयोगकर्ता के लिए सामग्री को अनुकूलित करता है।

उपयोग करने के लिए LocaleMiddleware , 'django.middleware.locale.LocaleMiddleware' अपनी MIDDLEWARE सेटिंग में जोड़ें । क्योंकि मिडलवेयर ऑर्डर मायने रखता है, इन दिशानिर्देशों का पालन करें:

  • सुनिश्चित करें कि यह स्थापित पहले मिडलवेयर में से एक है।
  • इसके बाद आना चाहिए SessionMiddleware , क्योंकि LocaleMiddleware सत्र डेटा का उपयोग करता है। और यह पहले आना चाहिए CommonMiddleware क्योंकि CommonMiddleware अनुरोधित URL को हल करने के लिए एक सक्रिय भाषा की आवश्यकता होती है।
  • यदि आप उपयोग करते हैं CacheMiddleware , तो LocaleMiddleware इसके बाद रखें।

उदाहरण के लिए, आपका ऐसा MIDDLEWARE दिख सकता है:

MIDDLEWARE = [
   'django.contrib.sessions.middleware.SessionMiddleware',
   'django.middleware.locale.LocaleMiddleware',
   'django.middleware.common.CommonMiddleware',
]

(मिडलवेयर पर अधिक जानकारी के लिए, मिडलवेयर प्रलेखन देखें ।)

LocaleMiddleware इस एल्गोरिथ्म का पालन करके उपयोगकर्ता की भाषा वरीयता निर्धारित करने की कोशिश करता है:

  • सबसे पहले, यह अनुरोधित URL में भाषा उपसर्ग के लिए दिखता है। यह केवल तब किया जाता है जब आप i18n_patterns अपने रूट URLconf में फ़ंक्शन का उपयोग कर रहे हों। अंतर्राष्ट्रीयकरण देखें : भाषा उपसर्ग के बारे में अधिक जानकारी के लिए URL पैटर्न में और URL पैटर्न का अंतर्राष्ट्रीयकरण कैसे करें।
  • असफल होना, यह LANGUAGE_SESSION_KEY वर्तमान उपयोगकर्ता के सत्र में कुंजी की तलाश करता है।
  • असफल होने पर, यह एक कुकी की तलाश करता है।

    उपयोग किए गए कुकी का नाम LANGUAGE_COOKIE_NAME सेटिंग द्वारा निर्धारित किया गया है। (डिफ़ॉल्ट नाम है django_language )

  • असफल होने पर, यह Accept-Language HTTP हेडर को देखता है । यह हेडर आपके ब्राउज़र द्वारा भेजा जाता है और सर्वर को बताता है कि आप किस भाषा (भाषा) को प्राथमिकता देते हैं। Django हेडर में प्रत्येक भाषा को तब तक आज़माता है जब तक कि वह उपलब्ध अनुवादों के साथ न मिल जाए।
  • असफल होने पर, यह वैश्विक LANGUAGE_CODE सेटिंग का उपयोग करता है ।

टिप्पणियाँ:

  • इनमें से प्रत्येक स्थान पर, भाषा की प्राथमिकता मानक भाषा प्रारूप में एक स्ट्रिंग के रूप में होने की उम्मीद है । उदाहरण के लिए, ब्राज़ीलियाई पुर्तगाली है pt-br
  • यदि कोई आधार भाषा उपलब्ध है, लेकिन उप भाषा निर्दिष्ट नहीं है, तो Django बेस भाषा का उपयोग करता है। उदाहरण के लिए, यदि कोई उपयोगकर्ता de-at (ऑस्ट्रियाई जर्मन) निर्दिष्ट de करता है, लेकिन Django केवल उपलब्ध है, तो Django उपयोग करता है de
  • LANGUAGES सेटिंग में सूचीबद्ध भाषाओं को ही चुना जा सकता है। यदि आप भाषा चयन को प्रदान की गई भाषाओं के सबसेट तक सीमित करना चाहते हैं (क्योंकि आपका एप्लिकेशन उन सभी भाषाओं को प्रदान नहीं करता है), LANGUAGES भाषाओं की सूची में सेट किया गया है। उदाहरण के लिए:

    LANGUAGES = [
      ('de', _('German')),
      ('en', _('English')),
    ]
    

    यह उदाहरण उन भाषाओं को प्रतिबंधित करता है जो जर्मन और अंग्रेजी के लिए स्वचालित चयन के लिए उपलब्ध हैं (और किसी भी उप भाषा की तरह, de-ch या en-us )।

  • यदि आप एक कस्टम LANGUAGES सेटिंग को परिभाषित करते हैं, जैसा कि पिछली बुलेट में बताया गया है, तो आप भाषा के नामों को अनुवाद स्ट्रिंग के रूप में चिह्नित कर सकते हैं - लेकिन एक परिपत्र आयात से बचने gettext_lazy() के gettext() लिए उपयोग करें ।

    यहाँ एक नमूना सेटिंग्स फ़ाइल है:

    from django.utils.translation import gettext_lazy as _
    
    LANGUAGES = [
        ('de', _('German')),
        ('en', _('English')),
    ]
    

एक बार LocaleMiddleware उपयोगकर्ता की प्राथमिकता निर्धारित करने के बाद , यह इस वरीयता request.LANGUAGE_CODE को प्रत्येक के लिए उपलब्ध कराता है HttpRequest । अपने मूल्य कोड में इस मूल्य को पढ़ने के लिए स्वतंत्र महसूस करें। यहाँ एक सरल उदाहरण दिया गया है:

from django.http import HttpResponse

def hello_world(request, count):
    if request.LANGUAGE_CODE == 'de-at':
        return HttpResponse("You prefer to read Austrian German.")
    else:
        return HttpResponse("You prefer to read another language.")

ध्यान दें कि, स्थैतिक (मिडलवेयर-कम) अनुवाद के साथ, भाषा में है settings.LANGUAGE_CODE , जबकि गतिशील (मिडलवेयर) अनुवाद के साथ, यह अंदर है request.LANGUAGE_CODE

कैसे Django अनुवाद का पता चलता है

रनगो में, Django शाब्दिक-अनुवादों की एक-मेमोरी एकीकृत सूची बनाता है। इसे प्राप्त करने के लिए यह इस एल्गोरिथ्म का अनुसरण करते हुए अनुवादों के लिए खोज करता है जिसमें यह संकलित संदेश फाइलों ( .mo ) और एक ही शाब्दिक के लिए कई अनुवादों की पूर्वता को लोड करने के लिए अलग-अलग फ़ाइल पथों की जांच करता है :

  1. जिन सूचियों को सूचीबद्ध किया गया LOCALE_PATHS है, उनमें सबसे अधिक पूर्वता होती है, जो पहले दिखाई देने की तुलना में पहले उच्च स्तर की होती है।
  2. उसके बाद, यह खोजता है और उपयोग करता है यदि यह locale सूची में स्थापित प्रत्येक एप्लिकेशन में एक निर्देशिका मौजूद है INSTALLED_APPS । पहले दिखने वाले लोगों में बाद में दिखने वाले लोगों की तुलना में अधिक पूर्वता होती है।
  3. अंत में, Django द्वारा प्रदान किया गया बेस ट्रांसलेशन django/conf/locale एक कमबैक के रूप में उपयोग किया जाता है।

यह भी देखें

जावास्क्रिप्ट संपत्ति में शामिल शाब्दिक अनुवादों को एक समान लेकिन समान एल्गोरिथ्म के बाद नहीं देखा जाता है। JavaScriptCatalog अधिक जानकारी के लिए देखें।

यदि आप सेट करते हैं, तो आप निर्देशिका में कस्टम प्रारूप फ़ाइलें भी रख सकते हैं । LOCALE_PATHS FORMAT_MODULE_PATH

सभी मामलों में अनुवाद वाले निर्देशिका का नाम स्थानीय नाम संकेतन का उपयोग करके नाम रखा जाना चाहिए । उदाहरण के लिए de , pt_BR , es_AR , आदि क्षेत्रीय भाषा वेरिएंट के लिए अनुवाद नहीं तार सामान्य भाषा का अनुवाद का उपयोग करें। उदाहरण के लिए, अनियंत्रित pt_BR तार pt अनुवाद का उपयोग करते हैं ।

Django 2.1 में परिवर्तित:

ऊपर वर्णित के रूप में जेनेरिक भाषा के लिए वापसी जोड़ा गया था।

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

सभी संदेश फ़ाइल रिपॉजिटरी को उसी तरह संरचित किया जाता है। वो हैं:

  • LOCALE_PATHS आपकी सेटिंग फ़ाइल में सूचीबद्ध सभी पथ खोजे जाते हैं <language>/LC_MESSAGES/django.(po|mo)
  • $APPPATH/locale/<language>/LC_MESSAGES/django.(po|mo)
  • $PYTHONPATH/django/conf/locale/<language>/LC_MESSAGES/django.(po|mo)

संदेश फ़ाइलों को बनाने के लिए, आप makemessages उपकरण का उपयोग करते हैं । और आप उपयोग की django-admin compilemessages जाने वाली बाइनरी .mo फ़ाइलों का उत्पादन करने के लिए उपयोग करते हैं gettext

आप django-admin compilemessages --settings=path.to.settings अपनी LOCALE_PATHS सेटिंग में सभी निर्देशिकाओं को संकलक प्रक्रिया बनाने के लिए भी चला सकते हैं ।

एक गैर-अंग्रेजी आधार भाषा का उपयोग करना

Django सामान्य धारणा बनाता है कि एक अनुवाद योग्य परियोजना में मूल तार अंग्रेजी में लिखे गए हैं। आप दूसरी भाषा चुन सकते हैं, लेकिन आपको कुछ सीमाओं के बारे में पता होना चाहिए:

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

Original text