Django i18n: .po கோப்பு மொழிபெயர்ப்பை தானியங்குபடுத்துவதற்கான முழுமையான வழிகாட்டி

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

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

நிலையான Django i18n பணிப்போக்கு

Django-வின் உள்ளமைக்கப்பட்ட i18n அமைப்பு நன்கு வடிவமைக்கப்பட்டுள்ளது. முக்கிய சுழற்சி இவ்வாறு இருக்கும்:

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

from django.utils.translation import gettext as _

def dashboard(request):
    welcome = _("Welcome back, %(name)s!") % {"name": request.user.first_name}
    return render(request, "dashboard.html", {"welcome": welcome})

{% load i18n %}
<h1>{% trans "Account Settings" %}</h1>
<p>{% blocktrans %}You have {{ count }} unread messages.{% endblocktrans %}</p>

படி 2: சரங்களைப் பிரித்தெடுக்கவும் .po கோப்புகளுக்குள்:

python manage.py makemessages -l de -l fr -l nl

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

#: myapp/views.py:4
msgid "Welcome back, %(name)s!"
msgstr ""

#: templates/dashboard.html:2
msgid "Account Settings"
msgstr ""

படி 3: ஒவ்வொரு காலியான msgstr-ஐயும் மொழிபெயர்க்கவும் கையால்.

படி 4: தொகுக்கவும் முடிக்கப்பட்ட .po கோப்புகளை பைனரி .mo கோப்புகளாக:

python manage.py compilemessages

படிகள் 1, 2, மற்றும் 4 விரைவானவை. படி 3 தான் செயல்முறை முறிவடையும் இடம்.

கைமுறை மொழிபெயர்ப்பு ஏன் அளவிடாது

ஒரு பொதுவான Django பயன்பாட்டில் 200 முதல் 2,000 மொழிபெயர்க்கக்கூடிய சரங்கள் இருக்கும். அதை இலக்கு மொழிகளின் எண்ணிக்கையால் பெருக்கினால், கணிசமான நேர முதலீட்டைப் பார்க்கிறீர்கள்.

இது ஒரு கோட்பாட்டு புகார் அல்ல. ஒரு நன்கு அறியப்பட்ட Django Forum நூலில், ஒரு டெவலப்பர் கைமுறை மொழிபெயர்ப்புகள் செய்வதற்கு ஒரு .po கோப்புக்கு 8+ மணி நேரம் செலவிட்டதாக அறிவித்தார். ஒரு Django core பங்களிப்பாளர் ஒரு வெளியீட்டில் சமூகம் சமர்ப்பித்த மொழிபெயர்ப்புகளை இணைக்க 10 மணி நேரத்திற்கு மேல் செலவிட்டதாக விவரித்தார், பெரும்பாலும் மதிப்பாய்வு, வடிவமைப்பு திருத்தங்கள் மற்றும் உடைந்த placeholder-களை சரிசெய்தல் ஆகியவற்றில்.

சிக்கல்கள் காலப்போக்கில் கூட்டாகிறது:

• Placeholder-கள் உடைகின்றன. Welcome, %(name)s! போன்ற ஒரு சரத்தை Google Translate-ல் நகலெடுங்கள், நீங்கள் பெரும்பாலும் Willkommen, %(Name)s! அல்லது Bienvenue, %(nom)s! எனத் திரும்பப் பெறுவீர்கள். அந்த நுட்பமான சிதைவு இயக்க நேர செயலிழப்புகளை ஏற்படுத்துகிறது.
• நிலைத்தன்மை விலகுகிறது. சொல்லகராதி இல்லாமல், "dashboard" ஒரு கோப்பில் "Instrumententafel" எனவும் மற்றொன்றில் "Dashboard" எனவும் மொழிபெயர்க்கப்படுகிறது. மூன்று மாதங்களுக்குப் பிறகு, எது வேண்டுமென்றே செய்யப்பட்டது என்பது யாருக்கும் நினைவில் இருக்காது.
• Sprint-கள் சரங்களைச் சேர்க்கின்றன. ஒவ்வொரு feature branch-ம் புதிய மொழிபெயர்க்கக்கூடிய சரங்களைச் சேர்க்கிறது. கடந்த காலாண்டில் முழு மொழிபெயர்ப்புக்கு பணம் செலுத்தியிருந்தாலும், இப்போது உங்கள் .po கோப்புகளில் 40 மொழிபெயர்க்கப்படாத உள்ளீடுகள் சிதறியிருக்கின்றன.
• AI உதவியாளர்கள் ஒரு முறை உதவுகிறார்கள். ஒரு .po கோப்பை ChatGPT அல்லது Claude-ல் ஒட்டி நல்ல முடிவுகளைப் பெறலாம். ஆனால் அடுத்த sprint-ல், 15 புதிய சரங்கள் தோன்றும்போது, நீங்கள் புதிதாக prompt செய்து, முழு கோப்பையும் மீண்டும் மொழிபெயர்த்து, ஏற்கனவே இருந்ததுடன் ஒத்திசைவாக இருக்கும் என நம்புகிறீர்கள்.

மூல காரணம் என்னவென்றால், மொழிபெயர்ப்பு ஒரு முறை நிகழ்வாகக் கருதப்படுகிறது, படிப்படியான, மீண்டும் செய்யக்கூடிய செயல்முறையாக அல்ல.

AI மூலம் மொழிபெயர்ப்பை தானியக்கமாக்குதல்

யோசனை நேரடியானது: ஒவ்வொரு .po கோப்பையும் திறந்து msgstr மதிப்புகளை நிரப்பும் மனிதனுக்குப் பதிலாக, ஒரு கருவி கோப்பைப் படிக்கிறது, மொழிபெயர்க்கப்படாத சரங்களை AI மாதிரி அல்லது மொழிபெயர்ப்பு API-க்கு அனுப்புகிறது, முடிவுகளை எழுதுகிறது, மற்றும் மற்ற அனைத்தையும் (கருத்துகள், கோப்பு கட்டமைப்பு, placeholder-கள், பன்மை வடிவங்கள்) பாதுகாக்கிறது.

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

படிப்படியான அமைப்பு

1. தொகுப்பை நிறுவுங்கள்

pip install translatebot-django

அல்லது, நீங்கள் uv பயன்படுத்தினால் (பரிந்துரைக்கப்படுகிறது):

uv add --dev translatebot-django

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

2. INSTALLED_APPS-ல் சேர்க்கவும்

# settings.py
INSTALLED_APPS = [
    # ...
    "translatebot_django",
]

3. உங்கள் AI வழங்குநரை உள்ளமைக்கவும்

# settings.py
import os

TRANSLATEBOT_API_KEY = os.getenv("OPENAI_API_KEY")
TRANSLATEBOT_MODEL = "gpt-4o-mini"

TranslateBot உள்ளே LiteLLM-ஐ பயன்படுத்துகிறது, அதாவது ஒரு சரத்தை மாற்றுவதன் மூலம் 100+ மாதிரிகளில் எதையும் மாற்றலாம்:

DeepL-க்கு, கூடுதல் நிறுவுங்கள்: pip install translatebot-django[deepl]. DeepL-ன் இலவச நிலை மாதத்திற்கு 500,000 எழுத்துக்களை இலவசமாக வழங்குகிறது, இது பெரும்பாலான சிறிய மற்றும் நடுத்தர திட்டங்களுக்குப் போதுமானது.

4. உங்கள் மொழிகளை வரையறுக்கவும்

# settings.py
LANGUAGES = [
    ("en", "English"),
    ("de", "German"),
    ("fr", "French"),
    ("nl", "Dutch"),
    ("ja", "Japanese"),
]

5. மொழிபெயர்ப்பை இயக்கவும்

python manage.py translate

அவ்வளவுதான். TranslateBot உங்கள் திட்டத்தை .po கோப்புகளுக்காக ஸ்கேன் செய்கிறது, மொழிபெயர்க்கப்படாத உள்ளீடுகளை அடையாளம் காண்கிறது, அவற்றை உகந்த தொகுதிகளில் உள்ளமைக்கப்பட்ட AI மாதிரிக்கு அனுப்புகிறது, மற்றும் முடிவுகளை எழுதுகிறது. ஏற்கனவே உள்ள மொழிபெயர்ப்புகள் தொடப்படுவதில்லை.

ஒரு மொழியை மட்டும் மொழிபெயர்க்க:

python manage.py translate --target-lang nl

வெளியீடு இவ்வாறு இருக்கும்:

Translating to Dutch (nl)...
Found 42 strings to translate
Translating batch 1/2...
Translating batch 2/2...
Successfully translated 42 strings

6. வழக்கம் போல் தொகுக்கவும்

python manage.py compilemessages

உங்கள் முழு பணிப்போக்கு இப்போது:

python manage.py makemessages -l de -l fr -l nl -l ja
python manage.py translate
python manage.py compilemessages

மூன்று கட்டளைகள். ஒவ்வொரு மொழி. ஒவ்வொரு sprint.

வடிவமைப்பிலேயே படிப்படியானது

மீண்டும் செய்யக்கூடிய பணிப்போக்கிற்கான மிக முக்கியமான அம்சம் படிப்படியான மொழிபெயர்ப்பு ஆகும். TranslateBot msgstr காலியாக இருக்கும் உள்ளீடுகளை மட்டுமே மொழிபெயர்க்கிறது. உங்களிடம் 500 சரங்கள் இருந்து இந்த sprint-ல் 15 புதியவை என்றால், அந்த 15 மட்டுமே API-க்கு அனுப்பப்படும்.

இது நடைமுறை காரணங்களுக்காக முக்கியம்:

1. செலவு. புதிய சரங்களுக்கு மட்டுமே பணம் செலுத்துகிறீர்கள், முழு கோப்புக்கு அல்ல.
2. வேகம். 15 சரங்களை மொழிபெயர்ப்பது நொடிகள் எடுக்கும், நிமிடங்கள் அல்ல.
3. நிலைத்தன்மை. நீங்கள் ஏற்கனவே மதிப்பாய்வு செய்து அங்கீகரித்த மொழிபெயர்ப்புகள் ஒருபோதும் மேலெழுதப்படாது (நீங்கள் வெளிப்படையாக --overwrite பயன்படுத்தாத வரை).

Placeholder பாதுகாப்பு

Django பல placeholder வடிவங்களைப் பயன்படுத்துகிறது: %(name)s, %s, %d, {0}, {name}, மற்றும் <strong> அல்லது <a href="..."> போன்ற உள்ளமை HTML குறிச்சொற்கள். இவற்றில் ஏதேனும் மொழிபெயர்ப்பில் சிதைந்தால், இயக்க நேர பிழைகள் அல்லது உடைந்த markup கிடைக்கும்.

TranslateBot AI மாதிரிக்கு அனைத்து placeholder வடிவங்களையும் பாதுகாக்க அறிவுறுத்தி வெளியீட்டை சரிபார்க்கிறது. இது போன்ற ஒரு சரம்:

Welcome to %(site_name)s! You have <strong>%(count)d</strong> new messages.

டச்சில் இவ்வாறு மொழிபெயர்க்கப்படுகிறது:

Welkom bij %(site_name)s! Je hebt <strong>%(count)d</strong> nieuwe berichten.

ஒவ்வொரு placeholder-ம் அப்படியே உயிர்வாழ்கிறது.

TRANSLATING.md மூலம் தரத்தைக் கட்டுப்படுத்துதல்

AI மாதிரிகள் சூழலைப் புரிந்துகொள்ளும்போது சிறப்பாக மொழிபெயர்க்கின்றன. TranslateBot உங்கள் திட்ட root-ல் TRANSLATING.md கோப்பைத் தேடி, ஒவ்வொரு மொழிபெயர்ப்பு கோரிக்கையிலும் அதன் உள்ளடக்கங்களைச் சேர்க்கிறது.

# Translation Context

## About This Project
A B2B project management tool for construction companies.

## Terminology
- "project" means a construction project, not a software project
- "plan" means a building plan/blueprint, not a subscription plan
- Keep "Gantt chart" as-is in all languages

## Tone
- German: use formal "Sie" form (business context)
- French: use formal "vous" form
- Dutch: use informal "je" form

## Do Not Translate
- Brand name: "BuildFlow"
- Feature names: "SmartSchedule", "CostTracker"

இந்த கோப்பு உங்கள் குறியீட்டுடன் பதிப்புக் கட்டுப்பாட்டில் உள்ளது, எனவே உங்கள் முழு குழுவும் ஒரே மொழிபெயர்ப்பு சூழலைப் பகிர்ந்துகொள்கிறது. சிறப்பு சொற்களகம் கொண்ட பயன்பாடுகளுக்கு ஒவ்வொரு app-க்கும் தனி TRANSLATING.md கோப்புகளையும் வைக்கலாம். மருத்துவப் பதிவுகள் தொகுதி மற்றும் கட்டணத் தொகுதி ஒவ்வொன்றும் தனது சொந்த சொல்லகராதியைக் கொண்டிருக்கலாம்.

Commit செய்வதற்கு முன் முன்னோட்டம்

--dry-run flag எந்த API அழைப்புகளும் செய்யாமல் அல்லது கோப்புகளை மாற்றாமல் என்ன மொழிபெயர்க்கப்படும் என்பதை சரியாகக் காட்டுகிறது:

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

Found 15 untranslated entries
Dry run mode: skipping LLM translation

Would translate 'Welcome to our site'
Would translate 'Hello, %(name)s!'
...

Dry run complete: 15 entries would be translated

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

CI/CD ஒருங்கிணைப்பு

அமலாக்கம் இல்லாமல் மொழிபெயர்ப்புகள் காலாவதியாவது தவிர்க்க முடியாதது. TranslateBot CI பைப்லைன்களுக்காக வடிவமைக்கப்பட்ட check_translations management command-ஐ உள்ளடக்குகிறது:

# .github/workflows/ci.yml
jobs:
  translations:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: astral-sh/setup-uv@v4
        with:
          enable-cache: true
      - run: uv python install
      - run: uv sync --frozen
      - name: Install gettext
        run: sudo apt-get update && sudo apt-get install -y --no-install-recommends gettext
      - name: Check translations
        run: uv run python manage.py check_translations --makemessages

--makemessages flag முதலில் makemessages -a --no-obsolete இயக்குகிறது, சரிபார்ப்பதற்கு முன் .po கோப்புகள் தற்போதைய மூலக் குறியீட்டை பிரதிபலிக்கின்றன என்பதை உறுதி செய்கிறது. ஏதேனும் உள்ளீடுகள் மொழிபெயர்க்கப்படாமல் அல்லது fuzzy ஆக இருந்தால், கட்டளை குறியீடு 1 உடன் வெளியேறி build-ஐ தோல்வியடையச் செய்கிறது:

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

வழக்கமான டெவலப்பர் பணிப்போக்கு:

1. Feature branch-ல் புதிய மொழிபெயர்க்கக்கூடிய சரங்களைச் சேர்க்கவும்.
2. அந்த சரங்கள் மொழிபெயர்க்கப்படாததால் CI தோல்வியடைகிறது.
3. உள்ளூரில் python manage.py translate இயக்கவும்.
4. புதுப்பிக்கப்பட்ட .po கோப்புகளை commit செய்யவும்.
5. CI தேர்ச்சியடைகிறது.

மொழிபெயர்ப்புகள் ஒருபோதும் அமைதியாக ஒத்திசைவிலிருந்து விலகாது.

தரவுத்தள உள்ளடக்கத்தை மொழிபெயர்த்தல்

உங்கள் பயன்பாடு தரவுத்தளத்தில் மொழிபெயர்க்கக்கூடிய உள்ளடக்கத்தை சேமித்தால் (தயாரிப்பு பெயர்கள், வலைப்பதிவு இடுகை தலைப்புகள், வகை லேபிள்கள்), TranslateBot django-modeltranslation-உடனும் ஒருங்கிணைகிறது:

pip install translatebot-django[modeltranslation]

# Translate all registered model fields
python manage.py translate --target-lang de --models

# Translate specific models only
python manage.py translate --target-lang de --models Product Category

அதே படிப்படியான தர்க்கம் பொருந்தும்: இலக்கு மொழி மதிப்பு காலியாக இருக்கும் புலங்கள் மட்டுமே மொழிபெயர்க்கப்படும்.

செலவு ஒப்பீடு

மிகவும் பொதுவான கேள்விகளில் ஒன்று, AI மொழிபெயர்ப்பு மாற்றுகளுடன் ஒப்பிடும்போது செலவு-திறனானதா என்பது. 5 மொழிகளில் 500 மொழிபெயர்க்கக்கூடிய சரங்களைக் கொண்ட ஒரு திட்டத்திற்கான தோராயமான ஒப்பீடு:

சரங்களின் எண்ணிக்கை மற்றும் இலக்கு மொழிகளைப் பொறுத்து எண்கள் மாறுகின்றன, ஆனால் அளவு வரிசை வேறுபாடு நிலையானது. தொடர்ச்சியான பராமரிப்புக்கு (ஒவ்வொரு sprint-லும் சேர்க்கப்படும் 20-50 புதிய சரங்களை மொழிபெயர்த்தல்), AI செலவு அடிப்படையில் பூஜ்ஜியம்.

சிறந்த நடைமுறைகள்

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

மொழிபெயர்ப்பதற்கு முன் .po கோப்புகளை commit செய்யுங்கள். ஏதாவது தவறானால், git checkout உடனடியாக சுத்தமான நிலைக்குத் திரும்பும்.

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

CI-ல் check_translations சேர்க்கவும். இந்த ஒற்றை படி மிகவும் பொதுவான i18n தோல்வி முறையைத் தடுக்கிறது: மொழிபெயர்ப்புக்காகக் குறிக்கப்பட்ட ஆனால் உண்மையில் மொழிபெயர்க்கப்படாத சரங்கள்.

செலவு திறனுக்கு gpt-4o-mini அல்லது DeepL பயன்படுத்துங்கள். துல்லியம் முக்கியமான திட்டங்களுக்கு GPT-4o அல்லது Claude போன்ற பிரீமியம் மாதிரிகளை சேமியுங்கள், மார்க்கெட்டிங் நகல், சட்ட உரை அல்லது துறை-குறிப்பிட்ட சொற்பொருள் போன்றவை.

முக்கியமான சரங்களை மதிப்பாய்வு செய்யுங்கள். AI மொழிபெயர்ப்புகள் பெரும்பாலான UI உரைக்குப் போதுமானவை, ஆனால் சட்டரீதியாக கட்டுப்படுத்தும், பாதுகாப்புக்கு முக்கியமான அல்லது உயர்-பங்கு சூழலில் வாடிக்கையாளர் எதிர்கொள்ளும் எதையும் ஒரு தாய்மொழி பேசுபவரிடம் மதிப்பாய்வு செய்யச் சொல்லுங்கள்.

மணி நேரங்களிலிருந்து நொடிகளுக்கு

Django-வின் i18n கட்டமைப்பு மொழிபெயர்ப்புகளைப் பிரித்தெடுப்பதிலும் தொகுப்பதிலும் சிறந்தது. இடைவெளி எப்போதும் மொழிபெயர்ப்பு படியிலேயே இருந்தது - பல மொழிகளில் நூற்றுக்கணக்கான msgstr மதிப்புகளை நிரப்பும் கடினமான, பிழை எளிதில் ஏற்படும் வேலை.

TranslateBot அந்த இடைவெளியை மூடுகிறது. நிறுவி, AI வழங்குநரை சுட்டிக்காட்டி, ஒரு கட்டளையை இயக்குங்கள். புதிய சரங்கள் மொழிபெயர்க்கப்படுகின்றன. ஏற்கனவே உள்ள சரங்கள் தொடப்படாமல் இருக்கின்றன. Placeholder-கள் அப்படியே இருக்கின்றன. CI எதையும் தவறவிடாமல் பிடிக்கிறது.

உங்கள் .po கோப்புகள் ஒரு சிரமமாக இருப்பதை நிறுத்தி, build-ன் மற்றொரு பகுதியாக மாறுகின்றன.

pip install translatebot-django

translatebot.dev-ல் தொடங்குங்கள்.