Django மொழிபெயர்ப்புகள் ஏன் உடைகின்றன (மற்றும் 10 பொதுவான காரணங்களை சரிசெய்வது எப்படி)

நீங்கள் மொழிபெயர்ப்புக்காக சரங்களைக் குறிக்கீடிட்டீர்கள், .po கோப்புகளை உருவாக்கினீர்கள், compilemessages இயக்கினீர்கள், ஆனால் உங்கள் பயன்பாடு இன்னும் ஆங்கிலத்தில் காட்டுகிறது. நீங்கள் தனியாக இல்லை. Django-வின் i18n கட்டமைப்பு சக்தி வாய்ந்தது, ஆனால் அனுபவமுள்ள டெவலப்பர்களையும் பிடிக்கும் கூர்மையான விளிம்புகள் உள்ளன.

இந்த வழிகாட்டி Django மொழிபெயர்ப்புகள் அமைதியாகத் தோல்வியடையும் 10 பொதுவான காரணங்களை, ஒவ்வொன்றுக்கும் சரியான அறிகுறிகள் மற்றும் தீர்வுகளுடன் உள்ளடக்கியது.

1. .po கோப்புகளைத் திருத்திய பிறகு compilemessages இயக்க மறப்பது

நீங்கள் ஒரு .po கோப்பை (கைமுறையாகவோ அல்லது ஒரு கருவி மூலமாகவோ) திருத்தினீர்கள், ஆனால் மொழிபெயர்க்கப்பட்ட உரை ஒருபோதும் தோன்றவில்லை. பயன்பாடு அசல் ஆங்கில சரங்களைக் காட்டிக்கொண்டே இருக்கிறது.

Django இயக்க நேரத்தில் .po கோப்புகளைப் படிக்காது. அதற்குப் பதிலாக தொகுக்கப்பட்ட .mo (machine object) பைனரி கோப்புகளைப் படிக்கும். நீங்கள் ஒரு .po கோப்பை மீண்டும் தொகுக்காமல் திருத்தினால், Django எதுவும் மாறியதை அறியாது.

ஒவ்வொரு .po கோப்பு மாற்றத்திற்குப் பிறகும் compilemessages இயக்கவும்:

python manage.py compilemessages

TranslateBot மூலம் உங்கள் மொழிபெயர்ப்புகளை தானியக்கமாக்கினால், உங்கள் பணிப்போக்கின் இறுதி படியாக compilemessages சேர்க்கவும்:

python manage.py makemessages -a --no-obsolete
python manage.py translate
python manage.py compilemessages

2. டெம்ப்ளேட்களில் {% load i18n %} இல்லை

ஒரு டெம்ப்ளேட்டில் {% trans "Hello" %} பயன்படுத்துகிறீர்கள், ஆனால் Django TemplateSyntaxError எழுப்புகிறது. அல்லது இன்னும் மோசமாக, தவறாக உள்ளமைக்கப்பட்ட டெம்ப்ளேட் இயந்திரம் இருந்தால் குறிச்சொல் அமைதியாக எதுவும் செய்யாது.

{% trans %} மற்றும் {% blocktrans %} குறிச்சொற்கள் Django-வின் i18n டெம்ப்ளேட் குறிச்சொல் நூலகத்தில் உள்ளன. அதை ஏற்றாமல், டெம்ப்ளேட் இயந்திரம் அவற்றை அடையாளம் காணாது.

மொழிபெயர்ப்பு குறிச்சொற்களைப் பயன்படுத்தும் ஒவ்வொரு டெம்ப்ளேட்டின் மேலேயும் {% load i18n %} சேர்க்கவும்:

{% load i18n %}

<h1>{% trans "Welcome to our site" %}</h1>
<p>{% blocktrans with name=user.name %}Hello, {{ name }}!{% endblocktrans %}</p>

இது டெம்ப்ளேட்-வாரியான தேவையாகும். ஒரு பெற்றோர் டெம்ப்ளேட் i18n ஏற்றினாலும், மொழிபெயர்ப்பு குறிச்சொற்களைப் பயன்படுத்தும் குழந்தை டெம்ப்ளேட்களுக்கு அவற்றின் சொந்த {% load i18n %} அறிவிப்பு தேவை.

3. LocaleMiddleware MIDDLEWARE-ல் இல்லை அல்லது தவறான நிலையில் உள்ளது

உலாவியின் Accept-Language தலைப்பு, URL முன்னொட்டு அல்லது அமர்வு அமைப்புகளைப் பொருட்படுத்தாமல் Django எப்போதும் இயல்புநிலை மொழியில் உள்ளடக்கத்தை வழங்குகிறது.

LocaleMiddleware ஒவ்வொரு கோரிக்கைக்கும் செயலில் உள்ள மொழியை தீர்மானிக்கிறது. அது இல்லாமல், Django LANGUAGE_CODE-ஐ இயல்புநிலையாகப் பயன்படுத்தும் மற்றும் அனைத்து மொழி-தேர்வு வழிமுறைகளையும் புறக்கணிக்கும். middleware அடுக்கில் அதன் நிலையும் முக்கியமானது, ஏனெனில் அமர்வு தரவு மற்றும் URL தீர்மானத்திற்கான அணுகல் தேவை.

LocaleMiddleware-ஐ உங்கள் MIDDLEWARE அமைப்பில், SessionMiddleware மற்றும் CommonMiddleware-க்குப் பிறகு சேர்க்கவும்:

MIDDLEWARE = [
    "django.middleware.security.SecurityMiddleware",
    "django.contrib.sessions.middleware.SessionMiddleware",
    "django.middleware.common.CommonMiddleware",
    "django.middleware.locale.LocaleMiddleware",  # Must be after SessionMiddleware
    "django.middleware.csrf.CsrfViewMiddleware",
    "django.contrib.auth.middleware.AuthenticationMiddleware",
    "django.contrib.messages.middleware.MessageMiddleware",
]

URL அடிப்படையிலான மொழி மாற்றத்தைப் பயன்படுத்தினால், உங்கள் URL உள்ளமைவில் django.conf.urls.i18n சேர்க்கப்பட்டிருப்பதையும் உறுதிப்படுத்தவும்:

from django.conf.urls.i18n import i18n_patterns

urlpatterns = i18n_patterns(
    path("", include("myapp.urls")),
)

4. மொழி குறியீடு பொருத்தமின்மை (எ.கா., pt-br vs pt_BR)

உங்கள் .po கோப்புகளில் மொழிபெயர்ப்புகள் உள்ளன, compilemessages வெற்றிகரமாக இயங்குகிறது, ஆனால் Django குறிப்பிட்ட மொழி அமைப்புகளுக்கான மொழிபெயர்ப்பைப் புறக்கணிக்கிறது.

Django, மொழி அமைப்பு அடைவுகள் <language>_<COUNTRY> வடிவமைப்பை அடிக்கோடு பிரிப்பான் மற்றும் பெரிய எழுத்து நாட்டுக் குறியீட்டுடன் பின்பற்ற வேண்டும் என எதிர்பார்க்கிறது. எடுத்துக்காட்டாக, பிரேசிலிய போர்த்துகீசியத்திற்கு pt_BR. உங்கள் அடைவு pt-br, pt-BR அல்லது ptBR என பெயரிடப்பட்டிருந்தால், Django அதைக் கண்டுபிடிக்காது. LANGUAGES அமைப்புக்கும் இது பொருந்தும்: அங்குள்ள குறியீடுகள் இணைக்கோடுகளைப் (pt-br) பயன்படுத்துகின்றன, ஆனால் கோப்பு முறைமை அடிக்கோடுகளைப் (pt_BR) பயன்படுத்துகிறது.

உங்கள் அடைவு அமைப்பு Django-வின் எதிர்பார்ப்புகளுடன் பொருந்துவதை உறுதிப்படுத்தவும்:

locale/
    pt_BR/
        LC_MESSAGES/
            django.po
            django.mo

உங்கள் அமைப்புகளில், இணைக்கோடு வடிவத்தைப் பயன்படுத்தவும்:

LANGUAGES = [
    ("en", "English"),
    ("pt-br", "Brazilian Portuguese"),
    ("zh-hans", "Simplified Chinese"),
]

makemessages இயக்கும்போது, மொழி அமைப்பு கொடிக்கு அடிக்கோடு வடிவத்தைப் பயன்படுத்தவும்:

python manage.py makemessages -l pt_BR

5. தொகுப்பின் போது அமைதியாகத் தவிர்க்கப்படும் Fuzzy உள்ளீடுகள்

.po கோப்பில் ஒரு மொழிபெயர்ப்பு உள்ளது, ஆனால் Django அந்த குறிப்பிட்ட உள்ளீட்டிற்கு இயக்க நேரத்தில் அசல் ஆங்கில சரத்தைக் காட்டுகிறது. இது மிகவும் எரிச்சலூட்டும், ஏனெனில் மொழிபெயர்ப்பு கோப்பில் சரியாக இருக்கிறது.

Django-வின் makemessages ஒரு மூலச் சரம் சிறிது மாறியதைக் கண்டறிந்தால், ஏற்கனவே உள்ள மொழிபெயர்ப்பை "fuzzy" (அதாவது மனித மதிப்பாய்வு தேவைப்படும் ஒரு யூகம்) என குறிக்கிறது. compilemessages கட்டளை அனைத்து fuzzy உள்ளீடுகளையும் தவிர்த்து, அவற்றை மொழிபெயர்க்கப்படாதவை என நடத்துகிறது. எனவே உள்ளீடு .po கோப்பில் மொழிபெயர்க்கப்பட்டதாகத் தெரிகிறது, ஆனால் .mo கோப்பு அதை முழுமையாக விலக்குகிறது.

ஒரு fuzzy உள்ளீடு இவ்வாறு தோன்றும்:

#, fuzzy
msgid "Welcome to our website!"
msgstr "Welkom op onze website!"

மொழிபெயர்ப்பை மதிப்பாய்வு செய்து, தேவைப்பட்டால் msgstr-ஐ புதுப்பித்து, பிறகு #, fuzzy கொடியை அகற்றவும்:

msgid "Welcome to our website!"
msgstr "Welkom op onze website!"

பிறகு மீண்டும் தொகுக்கவும்:

python manage.py compilemessages

பெரிய திட்டத்தில், fuzzy உள்ளீடுகள் குவிந்து எளிதில் தவறவிடப்படும். TranslateBot-இன் check_translations கட்டளை இவற்றை தானாகப் பிடிக்கும்:

python manage.py check_translations

locale/nl/LC_MESSAGES/django.po: 0 untranslated, 3 fuzzy
CommandError: Translation check failed

உங்கள் CI குழாய்வழியில் check_translations --makemessages சேர்க்கவும், இனி ஒருபோதும் fuzzy உள்ளீட்டை வெளியிட மாட்டீர்கள்.

6. LOCALE_PATHS உள்ளமைக்கப்படவில்லை அல்லது தவறான அடைவை சுட்டிக்காட்டுகிறது

makemessages .po கோப்புகளை ஒரு இடத்தில் உருவாக்குகிறது, ஆனால் Django அவற்றை வேறு இடத்தில் தேடுகிறது. மொழிபெயர்ப்புகள் வட்டில் உள்ளன ஆனால் ஒருபோதும் ஏற்றப்படுவதில்லை.

Django மொழிபெயர்ப்பு கோப்புகளை ஒரு குறிப்பிட்ட வரிசையில் தேடுகிறது: முதலில் LOCALE_PATHS அடைவுகள், பிறகு ஒவ்வொரு பயன்பாட்டின் locale/ அடைவு, இறுதியாக திட்டத்தின் locale/ அடைவு. LOCALE_PATHS அமைக்கப்படவில்லை அல்லது தவறான பாதையை சுட்டிக்காட்டினால், Django உங்கள் .po கோப்புகளை ஒருபோதும் கண்டுபிடிக்காமல் போகலாம்.

உங்கள் அமைப்புகளில் LOCALE_PATHS-ஐ முழுமையான பாதையாக அமைக்கவும்:

from pathlib import Path

BASE_DIR = Path(__file__).resolve().parent.parent

LOCALE_PATHS = [
    BASE_DIR / "locale",
]

அடைவு இருப்பதையும் எதிர்பார்க்கப்படும் அமைப்பைக் கொண்டிருப்பதையும் சரிபார்க்கவும்:

locale/
    de/
        LC_MESSAGES/
            django.po
            django.mo
    nl/
        LC_MESSAGES/
            django.po
            django.mo

ஒரு பொதுவான தவறு LOCALE_PATHS-ஐ முழுமையான பாதைக்கு பதிலாக locale/ (சார்பு) என அமைப்பதாகும். Django உங்கள் திட்ட மூல அடைவிலிருந்து சார்பு பாதைகளை தீர்க்காது. இது செயல்முறையின் பணி அடைவைச் சார்ந்தது, அது பெரும்பாலும் நீங்கள் எதிர்பார்ப்பது போல் இருக்காது.

7. தற்காலிக சேமிப்பு பழைய மொழிபெயர்ப்புகளை வழங்குகிறது

நீங்கள் மொழிபெயர்ப்புகளை புதுப்பித்து தொகுத்தீர்கள், ஆனால் பழைய உரை தொடர்ந்து தோன்றுகிறது. சேவையகத்தை மீண்டும் தொடங்குவது சரிசெய்கிறது.

Django-வின் மொழிபெயர்ப்பு பட்டியல் செயல்முறைக்கு ஒருமுறை ஏற்றப்படுகிறது. உற்பத்தியில், Gunicorn அல்லது Uvicorn போன்ற WSGI/ASGI சேவையகங்கள் பணியாளர் செயல்முறைகளை நீண்ட காலத்திற்கு உயிருடன் வைக்கின்றன. .mo கோப்பு வட்டில் மாறியிருக்கலாம், ஆனால் இயங்கும் செயல்முறை இன்னும் நினைவகத்தில் பழைய மொழிபெயர்ப்புகளைக் கொண்டுள்ளது. மேலும், Django-வின் cache கட்டமைப்பை அல்லது Nginx அல்லது Cloudflare போன்ற தலைகீழ் proxy-ஐ பயன்படுத்தினால், தற்காலிக சேமிக்கப்பட்ட பதில்கள் காலாவதியாகும் வரை பழைய உள்ளடக்கத்தை வழங்கும்.

புதிய மொழிபெயர்ப்புகளை வரிசைப்படுத்திய பிறகு உங்கள் பயன்பாட்டு சேவையகத்தை மீண்டும் தொடங்கவும்:

# Gunicorn
kill -HUP $(cat /tmp/gunicorn.pid)

# Systemd
sudo systemctl restart myapp

# Docker
docker compose restart web

Django-வின் cache கட்டமைப்புக்கு, மொழிபெயர்ப்புகளை புதுப்பித்த பிறகு cache-ஐ அழிக்கவும்:

from django.core.cache import cache
cache.clear()

மேம்பாட்டில், runserver Python கோப்புகள் மாறும்போது தானாக மீண்டும் ஏற்றுகிறது ஆனால் .mo கோப்புகளைக் கண்காணிக்காது. compilemessages இயக்கிய பிறகு கைமுறையாக மீண்டும் தொடங்க வேண்டும்.

8. gettext (_() அல்லது {% trans %}) இல் மூடப்படாத சரங்கள்

makemessages சில சரங்களை பிரித்தெடுக்காது, எனவே அவை உங்கள் .po கோப்புகளில் ஒருபோதும் தோன்றாது மற்றும் ஒருபோதும் மொழிபெயர்க்கப்படாது. இது மிக அடிப்படையான சிக்கலாகும், பெரிய குறியீட்டு தளத்தில் கவனிக்காமல் விடுவதும் எளிதானது.

Django-வின் makemessages கட்டளை மொழிபெயர்ப்பு குறிப்பான்களுக்காக உங்கள் மூலக் குறியீட்டை ஸ்கேன் செய்ய xgettext பயன்படுத்துகிறது. ஒரு சரம் gettext() (பொதுவாக _() என மாற்றுப்பெயரிடப்படும்), gettext_lazy(), {% trans %} அல்லது {% blocktrans %} இல் மூடப்படவில்லை என்றால், பிரித்தெடுத்தல் செயல்முறைக்கு அது கண்ணுக்குத் தெரியாது.

பயனர் எதிர்கொள்ளும் ஒவ்வொரு சரத்தையும் மூடவும்:

# Python code
from django.utils.translation import gettext_lazy as _

class Article(models.Model):
    class Meta:
        verbose_name = _("article")
        verbose_name_plural = _("articles")

# Views
from django.utils.translation import gettext as _

def my_view(request):
    message = _("Your changes have been saved.")
    return HttpResponse(message)

<!-- Templates -->
{% load i18n %}
<h1>{% trans "Welcome" %}</h1>
<p>{% blocktrans with count=items|length %}You have {{ count }} items.{% endblocktrans %}</p>

பிரித்தெடுத்தலின் போது தவறவிடப்பட்ட சரங்களைப் பிடிக்க, தற்போது மொழிபெயர்க்கப்படாத சரங்களை முன்னோட்டமிட TranslateBot-இன் --dry-run கொடியைப் பயன்படுத்தவும்:

python manage.py translate --target-lang de --dry-run

இது எந்த API அழைப்புகளோ மாற்றங்களோ செய்யாமல் உங்கள் .po கோப்புகளில் உள்ள அனைத்து மொழிபெயர்க்கப்படாத உள்ளீடுகளையும் காட்டுகிறது.

9. f-string-களை மொழிபெயர்க்க இயலாது (Django வரம்பு)

ஒரு f-string-ஐ _() இல் மூடுகிறீர்கள், தொடரியல் பிழை கிடைக்கிறது அல்லது makemessages மொழிபெயர்க்க இயலாத உடைந்த/பகுதி சரத்தை பிரித்தெடுக்கிறது.

Python f-string-கள் இயக்க நேரத்தில் மதிப்பீடு செய்யப்படுகின்றன. xgettext பிரித்தெடுத்தல் கருவி மூலக் குறியீட்டை நிலையாக பகுப்பாய்வு செய்கிறது, எனவே {} அடைப்புக்குறிக்குள் உள்ள Python வெளிப்பாடுகளை மதிப்பீடு செய்ய இயலாது. இதன் அர்த்தம் _(f"Hello, {name}") என்பது நேரடி {name} வெளிப்பாட்டைக் கொண்ட சரமாக பிரித்தெடுக்கப்படுகிறது (அல்லது முழுமையாக பிரித்தெடுக்கத் தோல்வியடைகிறது), மற்றும் விளைவாக வரும் .po உள்ளீடு இயக்க நேர சரத்துடன் ஒருபோதும் பொருந்தாது.

அதற்குப் பதிலாக Django-வின் % வடிவமைப்பு அல்லது பெயரிடப்பட்ட இடங்காட்டிகளுடன் .format() பயன்படுத்தவும்:

# Wrong -- f-string cannot be extracted
message = _(f"Hello, {user.name}! You have {count} new messages.")

# Correct -- named placeholders
message = _("Hello, %(name)s! You have %(count)d new messages.") % {
    "name": user.name,
    "count": count,
}

# Also correct -- .format() with positional args
message = _("Hello, {0}! You have {1} new messages.").format(user.name, count)

இது TranslateBot அல்லது கருவி வரம்பு அல்ல. gettext எவ்வாறு செயல்படுகிறது என்பதற்கு அடிப்படையானது. மூலச் சரம் பிரித்தெடுக்கவும் இயக்க நேரத்தில் தேடவும் நிலையான எழுத்துகளாக இருக்க வேண்டும்.

TranslateBot இந்த அனைத்து இடங்காட்டி வடிவமைப்புகளையும் (%(name)s, {0}, %s, HTML குறிச்சொற்கள்) மொழிபெயர்ப்பின் போது பாதுகாக்கிறது, எனவே மொழிபெயர்க்கப்பட்ட சரங்கள் முழுமையாக செயல்படும்.

10. இடங்காட்டி வடிவமைப்பு சரம் பிழைகள் .po தொகுப்பை உடைக்கின்றன

compilemessages பிழையுடன் தோல்வியடைகிறது, அல்லது .po கோப்பில் #, python-format கொடி பொருத்தமின்மை உள்ளது, உள்ளீடு அமைதியாக நிராகரிக்கப்படுகிறது.

ஒரு மூலச் சரம் %(name)s போன்ற Python வடிவமைப்பு இடங்காட்டிகளைக் கொண்டிருக்கும்போது, Django .po உள்ளீட்டை #, python-format எனக் குறிக்கிறது. மொழிபெயர்ப்பில் வேறுபட்ட இடங்காட்டிகள் இருந்தால் (%(nome)s போன்ற எழுத்துப்பிழை, விடுபட்ட இடங்காட்டி அல்லது கூடுதல் இடங்காட்டி) gettext கருவிகள் உள்ளீட்டை நிராகரிக்கலாம் அல்லது compilemessages தோல்வியடையலாம். இது பொதுவாக கைமுறை மொழிபெயர்ப்புகளிலோ அல்லது இடங்காட்டி அர்த்தவியலைப் புரிந்துகொள்ளாத AI மொழிபெயர்ப்பு கருவிகளிலோ நிகழ்கிறது.

உடைந்த உள்ளீடு இவ்வாறு தோன்றும்:

#, python-format
msgid "Hello, %(name)s! You have %(count)d new messages."
msgstr "Hallo, %(naam)s! Je hebt %(count)d nieuwe berichten."

இங்கு %(naam)s என்பது %(name)s ஆக இருக்க வேண்டும். இடங்காட்டிகள் மூலத்துடன் சரியாகப் பொருந்த வேண்டும்.

மொழிபெயர்க்கப்பட்ட சரங்கள் மூலத்தின் அதே இடங்காட்டிகளைக் கொண்டிருப்பதை உறுதிப்படுத்தவும். எழுத்துப்பிழைகள், விடுபட்ட இடங்காட்டிகள் மற்றும் கூடுதல் இடங்காட்டிகளைச் சரிபார்க்கவும்.

இது TranslateBot உண்மையான நன்மை வழங்கும் ஒரு பகுதியாகும். அதன் இடங்காட்டி பாதுகாப்பு தர்க்கம் மொழிபெயர்க்கப்பட்ட வெளியீட்டில் உள்ள அனைத்து வடிவமைப்பு சரங்களும் (%(name)s, {0}, %s) மூலத்துடன் சரியாகப் பொருந்துவதை உறுதிசெய்கிறது. இடங்காட்டி கையாளுதல் 100% சோதனை கவரேஜால் உள்ளடக்கப்பட்டுள்ளது, எனவே மொழிபெயர்ப்பிலிருந்து வடிவமைப்பு சரம் பிழைகள் தொகுப்பு நேரத்தில் பிடிக்கப்படுவதற்குப் பதிலாக கருவி மட்டத்தில் அகற்றப்படுகின்றன.

கைமுறையாக மொழிபெயர்க்கிறீர்கள் அல்லது இடங்காட்டிகளைக் கையாளாத கருவியைப் பயன்படுத்துகிறீர்கள் என்றால், உங்கள் .po கோப்புகளை இதன் மூலம் சரிபார்க்கவும்:

msgfmt --check-format locale/de/LC_MESSAGES/django.po

இது gettext-இன் வடிவமைப்பு சரம் சரிபார்ப்பை இயக்கி, ஏதேனும் பொருத்தமின்மைகளை அறிக்கையிடுகிறது.

அனைத்தையும் ஒன்றாக இணைத்தல்: பாதுகாப்பான பணிப்போக்கு

இந்த சிக்கல்களில் பெரும்பாலானவை ஒரு பொதுவான அடிப்படைக் காரணத்தைப் பகிர்ந்துகொள்கின்றன: மறக்க எளிதான கைமுறை படிகள். இங்கே அனைத்து 10 சிக்கல்களையும் தடுக்கும் ஒரு பணிப்போக்கு உள்ளது:

# 1. Extract strings (catches #8 -- any new gettext-wrapped strings)
python manage.py makemessages -a --no-obsolete

# 2. Translate (catches #1, #5, #8, #9, #10 -- handles untranslated,
#    fuzzy, and placeholder issues automatically)
python manage.py translate

# 3. Compile (catches #1 -- generates .mo files)
python manage.py compilemessages

# 4. Verify in CI (catches everything that slipped through)
python manage.py check_translations --makemessages

படி 4-ஐ உங்கள் CI குழாய்வழியில் சேர்க்கவும், மொழிபெயர்க்கப்படாத சரங்கள், fuzzy உள்ளீடுகள் மற்றும் வடிவமைப்புப் பிழைகள் உற்பத்தியை அடைவதற்கு முன் build-ஐ தோல்வியடையச் செய்யும்.

விரைவு குறிப்பு அட்டவணை

இந்த சிக்கல்களில் பெரும்பாலானவை மொழிபெயர்ப்பு படியை தானியக்கமாக்கி CI-ல் சரிபார்ப்புகளை அமல்படுத்தும்போது மறைந்துவிடும். TranslateBot-இன் translate கட்டளை இடங்காட்டி பாதுகாப்பு மற்றும் படிப்படியான மொழிபெயர்ப்பை கையாளுகிறது, அதே நேரத்தில் check_translations உற்பத்தியை அடைவதற்கு முன் விழுந்த அனைத்தையும் (மொழிபெயர்க்கப்படாத உள்ளீடுகள், fuzzy கொடிகள் மற்றும் வடிவமைப்பு சரம் சிக்கல்கள்) பிடிக்கிறது.