Internationalisation (i18n) avec Django

Pourquoi Internationalisation (i18n) avec Django ?

L'Internationalisation (i18n) est un processus crucial pour les développeurs backend, permettant aux applications web de s'adapter à différentes cultures et langues. Au quotidien, un développeur peut rencontrer des problèmes tels que :

• Des utilisateurs souhaitant utiliser une application en français plutôt que dans la langue par défaut.
• Des contenus dynamiques qui doivent changer en fonction du paysage culturel.

Un cas d'usage concret serait une application de e-commerce international. Cette application doit être accessible à des utilisateurs dans différents pays, chacun parlant une langue différente et ayant des préférences locales particulières (par exemple, dates formatées différemment, unités métriques ou impériales).

Prerequis

Pour suivre ce tutoriel, vous aurez besoin de :

• Un environnement Python installé (3.6+ recommandé)
• Un éditeur de code (VSCode, PyCharm, etc.)
• Django 3.2+
• pip pour installer des packages Python
• Git (optionnel, mais utile pour la gestion du code source)

Concepts fondamentaux

1. Internationalisation (i18n)

Concept : La i18n est le processus de conception d'applications qui peuvent être adaptées à différentes cultures et langues sans avoir besoin de faire de grandes modifications.

Schéma mental :

+-------------------+
|   Application     |
|                   |
| [Texte]           |
| [Date]            |
| [Monnaie]         |
+-------------------+
        ↑
        | Adaptation locale
        +-------------------+
                |
                v
        +-------------------+
        |   Application i18n|
        |                   |
        | [Texte traduit]   |
        | [Date selon le pays]|
        | [Monnaie localisée] |
        +-------------------+

Code :

## settings.py
LANGUAGE_CODE = 'en-us'
TIME_ZONE = 'UTC'

INSTALLED_APPS = [
    ...
    'django.contrib.i18n',
]

2. Localization (l10n)

Concept : La l10n est le processus de traduction des contenus d'une application pour qu'ils soient compréhensibles et adaptés à une culture spécifique.

Schéma mental :

+-------------------+
|   Contenu source  |
|                   |
| [Texte]           |
| [Formatage]       |
+-------------------+
        ↑
        | Traduction
        +-------------------+
                |
                v
        +-------------------+
        |   Contenu localisé|
        |                   |
        | [Texte traduit]   |
        | [Formatage adapté]|
        +-------------------+

Code :

## models.py
from django.db import models

class Task(models.Model):
    title = models.CharField(_(max_length=255))
    description = models.TextField(_(blank=True, null=True))

    def __str__(self):
        return self.title

3. Gestion des traductions

Concept : Django utilise les fichiers .po (Portable Object) pour stocker les traductions.

Schéma mental :

+-------------------+
|   Fichier .po       |
|                   |
| [msgid]           |
| [msgstr]          |
+-------------------+
        ↑
        | Extraction des strings
        +-------------------+
                |
                v
        +-------------------+
        |   Fichiers compilés|
        |                   |
        | [mo files]        |
        +-------------------+

Code :

## Extraction des strings
python manage.py makemessages -l fr

## Compilation des .po en .mo
python manage.py compilemessages

4. Utilisation de tags et filtres dans les templates

Concept : Les tags et filtres permettent d'intégrer les traductions directement dans les templates.

Schéma mental :

+-------------------+
|   Template        |
|                   |
| "Bonjour"|trans
+-------------------+
        ↑
        | Traduction automatique
        +-------------------+
                |
                v
        +-------------------+
        |   Texte traduit   |
        +-------------------+

Code :

<!-- templates/task_list.html -->
{% load i18n %}
<h1>{% trans "Tâches" %}</h1>
<ul>
    {% for task in tasks %}
        <li>task.title|trans</li>
    {% endfor %}
</ul>

Mise en pratique : projet fil rouge

1. Création du projet

django-admin startproject task_manager
cd task_manager

2. Ajout de l'application

python manage.py startapp tasks

3. Configuration des applications dans settings.py

INSTALLED_APPS = [
    ...
    'tasks',
]

4. Création d'un modèle pour les tâches

Code :

## tasks/models.py
from django.db import models

class Task(models.Model):
    title = models.CharField(_(max_length=255))
    description = models.TextField(_(blank=True, null=True))

    def __str__(self):
        return self.title

5. Création d'un formulaire pour ajouter des tâches

Code :

## tasks/forms.py
from django import forms
from .models import Task

class TaskForm(forms.ModelForm):
    class Meta:
        model = Task
        fields = ['title', 'description']

6. Création d'une vue pour afficher les tâches

Code :

## tasks/views.py
from django.shortcuts import render, redirect
from .models import Task
from .forms import TaskForm

def task_list(request):
    if request.method == 'POST':
        form = TaskForm(request.POST)
        if form.is_valid():
            form.save()
            return redirect('task_list')
    else:
        form = TaskForm()

    tasks = Task.objects.all()
    return render(request, 'tasks/task_list.html', {'form': form, 'tasks': tasks})

7. Création du template pour afficher les tâches

Code :

<!-- templates/tasks/task_list.html -->
{% load i18n %}
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>{% trans "Gestionnaire de Tâches" %}</title>
</head>
<body>
    <h1>{% trans "Tâches" %}</h1>
    <form method="post">
        {% csrf_token %}
        form.as_p
        <button type="submit">{% trans "Ajouter" %}</button>
    </form>

    <ul>
        {% for task in tasks %}
            <li>task.title|trans - task.description|default:"Aucune description"</li>
        {% empty %}
            <li>{% trans "Aucune tâche enregistrée." %}</li>
        {% endfor %}
    </ul>
</body>
</html>

8. Ajout d'URLs

Code :

## tasks/urls.py
from django.urls import path
from .views import task_list

urlpatterns = [
    path('', task_list, name='task_list'),
]

Code :

## task_manager/urls.py
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('tasks.urls')),
]

9. Extraction des strings et compilation des traductions

python manage.py makemessages -l fr
python manage.py compilemessages

10. Création de fichiers .po pour la langue française

Code :

## tasks/locale/fr/LC_MESSAGES/django.po
msgid "Gestionnaire de Tâches"
msgstr "Task Manager"

msgid "Tâches"
msgstr "Tasks"

msgid "Ajouter"
msgstr "Add"

msgid "Aucune tâche enregistrée."
msgstr "No tasks registered."

msgid "Titre"
msgstr "Title"

msgid "Description"
msgstr "Description"

msgid "Aucune description"
msgstr "No description"

11. Compilation des traductions

python manage.py compilemessages

Erreurs frequentes et debugging

1. Erreur : TemplateDoesNotExist

Code incorrect :

## settings.py
TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                ...
            ],
        },
    },
]

Code correct :

## settings.py
TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [BASE_DIR / 'templates'],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                ...
            ],
        },
    },
]

2. Erreur : TranslationError: 'tasks' is not a valid translation string

Code incorrect :

<!-- templates/tasks/task_list.html -->
{% load i18n %}
<h1>{% trans "Tâches" %}</h1>
<ul>
    {% for task in tasks %}
        <li>task.title|trans</li>
    {% endfor %}
</ul>

Code correct :

<!-- templates/tasks/task_list.html -->
{% load i18n %}
<h1>{% trans "Tasks" %}</h1>
<ul>
    {% for task in tasks %}
        <li>task.title</li>
    {% endfor %}
</ul>

3. Erreur : Could not parse the template at line 0

Code incorrect :

<!-- templates/tasks/task_list.html -->
{% load i18n %}
<h1>{% trans "Tâches" %}</h1>
<ul>
    {% for task in tasks %}
        <li>task.title|trans</li>
    {% endfor %}
</ul>

Code correct :

<!-- templates/tasks/task_list.html -->
{% load i18n %}
<h1>{% trans "Tasks" %}</h1>
<ul>
    {% for task in tasks %}
        <li>task.title|trans</li>
    {% endfor %}
</ul>

Pour aller plus loin

1. Utilisation de django-modeltranslation

Concept : django-modeltranslation permet une traduction automatique des champs des modèles.

Lien : https://github.com/deschler/django-modeltranslation

2. Intégration avec le front-end

Concept : Utiliser django-js- i18n pour ajouter des traductions directement au front-end.

Lien : https://docs.djangoproject.com/en/3.2/ref/contrib/i18n/#module-django.contrib.staticfiles.templatetags.i18n

3. Gestion des fuseaux horaires

Concept : Utiliser django-timezone-field pour gérer les fuseaux horaires de manière plus intuitive.

Lien : https://pypi.org/project/django-timezone-field/

Défi pratique

1. Ajouter une fonctionnalité permettant d'assigner un responsable à chaque tâche dans l'application.
2. Intégrer un système de notifications pour les utilisateurs lorsqu'une nouvelle tâche est ajoutée ou mise à jour.

En suivant ce tutoriel, vous devriez être en mesure de créer une application web Django capable de gérer des tâches et qui supporte plusieurs langues. N'oubliez pas de tester votre application dans différents navigateurs et sur différentes plateformes pour vous assurer que tout fonctionne comme prévu.