# Django Internationalization (i18n)
***
**1. Set the Language Header**
```python
def set_language(request):
language = request.GET.get('lang', 'en')
if language in SUPPORTED_LANGUAGES:
request.session['lang'] = language
else:
request.session['lang'] = DEFAULT_LANGUAGE
```
**2. Get the Language from the Session**
```python
def get_language(request):
language = request.session.get('lang', DEFAULT_LANGUAGE)
return language
```
**3. Load the Translation**
```python
from django.utils import translation
def load_translation(language):
translation.activate(language)
translation.load_paths('your-translation-path')
```
**4. Set the Language Directive in the Template**
```html
```
**5. Translate a String**
```python
from django.utils.translation import gettext
def translate(string):
return gettext(string)
```
**6. Translate a Contextual String**
```python
from django.utils.translation import gettext_context
def translate_contextual(context, string):
return gettext_context(context)(string)
```
**7. Translate a Plural String**
```python
from django.utils.translation import pgettext
def translate_plural(context, singular, plural):
return pgettext(context, singular, plural)
```
**8. Translate a Template Variable**
```html
```
**9. Translate a Template Block**
```html
Hello, {{ name }}!
```
**10. Translate a Template Literal**
```html
{{ _('Hello, world!') }}
```
**11. Translate a Model Field**
```python
from django.utils.translation import ugettext_lazy
class Article(models.Model):
title = models.CharField(_('Title'), max_length=255)
```
**12. Translate a Model Choice**
```python
from django.utils.translation import ugettext_lazy
class Article(models.Model):
STATUS_CHOICES = (
(1, _('Draft')),
(2, _('Published')),
)
```
**13. Translate a Form Field**
```python
from django.utils.translation import gettext_lazy
class ArticleForm(forms.ModelForm):
class Meta:
model = Article
fields = ['title', 'content']
labels = {
'title': gettext_lazy('Title'),
'content': gettext_lazy('Content'),
}
```
**14. Translate a Form Widget**
```python
from django.utils.translation import gettext_lazy
class TranslatedTextInput(forms.TextInput):
def render(self, *args, **kwargs):
attrs = kwargs.get('attrs', {})
attrs['placeholder'] = gettext_lazy(attrs.pop('placeholder', ''))
return super().render(*args, attrs=attrs, **kwargs)
```
**15. Translate a Form Error**
```python
from django.utils.translation import gettext_lazy
class ArticleForm(forms.ModelForm):
class Meta:
model = Article
fields = ['title', 'content']
def clean_title(self):
title = self.cleaned_data['title']
if len(title) < 10:
raise forms.ValidationError(gettext_lazy('Title must be at least 10 characters long.'))
return title
```
**16. Translate a Template Filter**
```python
from django.utils.safestring import mark_safe
from django.utils.translation import gettext_lazy
@register.filter
def truncatechars_translated(value, arg):
try:
length = int(arg)
except ValueError:
return value
if len(value) > length:
return mark_safe('%s...' % value[:length])
else:
return value
```
**17. Translate a Template Tag**
```python
from django.template import Library
register = Library()
@register.tag
def translate_block(parser, token):
nodelist = parser.parse(('endtranslateblock',))
parser.delete_first_token()
return TranslateBlockNode(nodelist)
class TranslateBlockNode(Node):
def render(self, context):
language = get_language(context['request'])
translation = translation.get_translation(language)
with translation.override(language):
return self.nodelist.render(context)
```
**18. Translate a Template Variable**
```python
from django.template import Context, Template
context = Context({'name': 'John'})
template = Template('
')
template.render(context)
```
**19. Translate a Template Block**
```python
from django.template import Context, Template
context = Context({'name': 'John'})
template = Template('')
template.render(context)
```
**20. Translate a Template Literal**
```python
from django.template import Context, Template
context = Context({})
template = Template('{{ _("Hello, world!") }}')
template.render(context)
```
**21. Translate a Model Field**
```python
from django.db.models import CharField
class Article(models.Model):
title = CharField(_('Title'), max_length=255)
```
**22. Translate a Model Choice**
```python
from django.db.models import IntegerField, choices
class Article(models.Model):
STATUS_CHOICES = (
(1, _('Draft')),
(2, _('Published')),
)
status = IntegerField(_('Status'), choices=STATUS_CHOICES)
```
**23. Translate a Form Field**
```python
from django.forms import CharField
class ArticleForm(forms.ModelForm):
title = CharField(label=_('Title'))
```
**24. Translate a Form Widget**
```python
from django.forms import TextInput
class TranslatedTextInput(TextInput):
def render(self, name, value, attrs=None):
attrs = attrs or {}
attrs['placeholder'] = _('Enter your name')
return super().render(name, value, attrs)
```
**25. Translate a Form Error**
```python
from django.forms import ValidationError
class ArticleForm(forms.ModelForm):
title = forms.CharField(label=_('Title'))
def clean_title(self):
title = self.cleaned_data['title']
if len(title) < 10:
raise ValidationError(_('Title must be at least 10 characters long.'))
return title
```
**26. Translate a Template Filter**
```python
from django.template import Library, TemplateSyntaxError
register = Library()
@register.filter
def translate_filter(value, arg):
try:
language_code, string = arg.split(':')
except ValueError:
raise TemplateSyntaxError('Invalid syntax for translate filter: %s' % arg)
return gettext_lazy(string, language=language_code)(value)
```
**27. Translate a Template Tag**
```python
from django.template import Library, Node, TemplateSyntaxError
register = Library()
@register.tag
def translate_tag(parser, token):
try:
language_code, string = token.split_contents()
except ValueError:
raise TemplateSyntaxError('Invalid syntax for translate tag: %s' % token.contents)
return TranslateNode(language_code, string)
class TranslateNode(Node):
def __init__(self, language_code, string):
self.language_code = language_code
self.string = string
def render(self, context):
return gettext_lazy(self.string, language=self.language_code)
```
**28. Translate a URL**
```python
from django.conf.urls import url
def translate_url_pattern(pattern, language_code):
prefix = 'i18n/%s/' % language_code
return url(prefix + pattern.regex.pattern, pattern.callback, name=pattern.name)
```
**29. Translate a Middleware**
```python
from django.utils.deprecation import MiddlewareMixin
class TranslationMiddleware(MiddlewareMixin):
def process_request(self, request):
language = request.GET.get('lang', request.session.get('lang', 'en'))
translation.activate(language)
request.LANGUAGE_CODE = language
```
**30. Translate a Context Processor**
```python
from django.conf import settings
def translation_context_processor(request):
return {
'LANGUAGE_CODE': request.LANGUAGE_CODE,
'LANGUAGES': settings.LANGUAGES,
}
```
**31. Translate a Formset**
```python
from django.forms import formset_factory
TranslatedFormset = formset_factory(
TranslatedForm,
extra=3,
max_num=5,
)
```
**32. Translate a ModelFormSet**
```python
from django.forms import modelformset_factory
TranslatedModelFormset = modelformset_factory(
TranslatedModel,
fields=['title', 'content'],
extra=3,
max_num=5,
)
```
**33. Translate a ModelAdmin**
```python
from django.contrib import admin
class TranslatedModelAdmin(admin.ModelAdmin):
list_display = ('title', 'content', 'created_at')
```
**34. Translate a ModelViewSet**
```python
from django.contrib import viewsets
class TranslatedModelViewSet(viewsets.ModelViewSet):
queryset = TranslatedModel.objects.all()
serializer_class = TranslatedModelSerializer
```
**35. Translate a DRF Serializer**
```python
from django.contrib.auth.models import User
from rest_framework import serializers
class TranslatedModelSerializer(serializers.ModelSerializer):
class Meta:
model = TranslatedModel
fields = ['title', 'content', 'created_at']
```
**36. Translate a WSGI Application**
```python
from django.core.handlers.wsgi import WSGIHandler
def translate_wsgi_app(application):
def middleware(environ, start_response):
language = environ.get('HTTP_ACCEPT_LANGUAGE', 'en')
translation.activate(language)
return application(environ, start_response)
return middleware
```