Localization & Time Zones

{% load l10n tz humanize %}
{% get_current_timezone as TIME_ZONE %}
<p>Time zone: {{ TIME_ZONE }}</p>
<ul>
{% for book in books %}
  <li>{{ book.title }} | {{ book.price }} | {{ book.published_at }} | {{ book.published_at|date:"DATE_FORMAT" }}
      | raw: {{ book.price|unlocalize }} | {{ book.published_at|timezone:"Asia/Tokyo" }}</li>
{% endfor %}
</ul>
<p>{% localize off %}{{ 1234567.5 }}{% endlocalize %} vs {% localize on %}{{ 1234567.5 }}{% endlocalize %} vs {{ 1234567|intcomma }}</p>

curl -s http://localhost:52411/books/ -H 'Accept-Language: de' | grep -E "Time zone|Dune|vs"

<p>Time zone: UTC</p>
  <li>Dune | 1234,50 | 3. Oktober 2026 12:00 | 3. Oktober 2026
<p>1234567.5 vs 1234567,5 vs 1.234.567</p>

class FormatTests(TestCase):
    def test_localize_tags_and_filters(self):
        template = Template(
            "{% load l10n %}{{ v }}|{{ v|unlocalize }}|{% localize off %}{{ v }}{% endlocalize %}"
        )
        with translation.override("de"):
            self.assertEqual(template.render(Context({"v": Decimal("1234.5")})), "1234,5|1234.5|1234.5")

    @override_settings(USE_THOUSAND_SEPARATOR=True)
    def test_thousand_separator(self):
        template = Template("{{ v }}")
        with translation.override("de"):
            self.assertEqual(template.render(Context({"v": 1234567})), "1.234.567")

from django import forms

from .models import Book


class BookForm(forms.ModelForm):
    class Meta:
        model = Book
        fields = ["title", "price", "published_at"]
        localized_fields = ["price"]

def test_localized_input_is_parsed_with_locale_formats(self):
    class PriceForm(forms.Form):
        price = forms.DecimalField(max_digits=8, decimal_places=2, localize=True)

    with translation.override("de"):
        form = PriceForm({"price": "1234,50"})
        self.assertTrue(form.is_valid(), form.errors)
        self.assertEqual(form.cleaned_data["price"], Decimal("1234.50"))
        self.assertFalse(PriceForm({"price": "1.234,50"}).is_valid())  # grouping not accepted by default
        with self.settings(USE_THOUSAND_SEPARATOR=True):
            self.assertEqual(PriceForm({"price": "1.234,50"}).fields["price"].clean("1.234,50"), Decimal("1234.50"))
    with translation.override("en"):
        self.assertFalse(PriceForm({"price": "1234,50"}).is_valid())

config/
    formats/
        __init__.py
        en/
            __init__.py
            formats.py

# Overrides only the English formats; every other name keeps Django's default.
DATE_FORMAT = "j M Y"
THOUSAND_SEPARATOR = " "  # narrow no-break space instead of a comma

FORMAT_MODULE_PATH = ["config.formats"]

import datetime
import zoneinfo

from django.utils import timezone

now = timezone.now()
print(timezone.is_aware(now), now.tzinfo)
print(timezone.get_current_timezone_name(), timezone.get_default_timezone_name())
paris = zoneinfo.ZoneInfo("Europe/Paris")
with timezone.override(paris):
    print(timezone.get_current_timezone_name(),
          timezone.localtime(datetime.datetime(2026, 10, 3, 12, 0, tzinfo=datetime.timezone.utc)))
print(timezone.get_current_timezone_name())

True UTC
UTC UTC
Europe/Paris 2026-10-03 14:00:00+02:00
UTC

import datetime
import zoneinfo

from django.utils import timezone

paris = zoneinfo.ZoneInfo("Europe/Paris")
naive = datetime.datetime(2026, 10, 3, 14, 30)
print(timezone.make_aware(naive, paris))
print(timezone.make_naive(timezone.make_aware(naive, paris), paris))

ny = zoneinfo.ZoneInfo("America/New_York")
gap = datetime.datetime(2026, 3, 8, 2, 30)  # does not exist: clocks jump from 02:00 to 03:00
print("gap", timezone.make_aware(gap, ny), timezone.make_aware(gap, ny).utcoffset())
amb = datetime.datetime(2026, 11, 1, 1, 30)  # happens twice
print("fold0", amb.replace(tzinfo=ny, fold=0).utcoffset(), "fold1", amb.replace(tzinfo=ny, fold=1).utcoffset())

2026-10-03 14:30:00+02:00
2026-10-03 14:30:00
gap 2026-03-08 02:30:00-05:00 -1 day, 19:00:00
fold0 -1 day, 20:00:00 fold1 -1 day, 19:00:00

def test_dst_gap_and_fold(self):
    gap = datetime.datetime(2026, 3, 8, 2, 30)  # does not exist in New York
    self.assertEqual(timezone.make_aware(gap, NEW_YORK).utcoffset(), datetime.timedelta(hours=-5))
    ambiguous = datetime.datetime(2026, 11, 1, 1, 30)
    first = ambiguous.replace(tzinfo=NEW_YORK, fold=0)
    second = ambiguous.replace(tzinfo=NEW_YORK, fold=1)
    self.assertEqual(second.astimezone(UTC) - first.astimezone(UTC), datetime.timedelta(hours=1))

import zoneinfo

from django.utils.dateparse import parse_datetime

naive = parse_datetime("2012-02-21 10:28:45")
aware = naive.replace(tzinfo=zoneinfo.ZoneInfo("Europe/Helsinki"))
print(aware)

2012-02-21 10:28:45+02:00

def test_stored_in_utc_and_shown_in_current_zone(self):
    stored = datetime.datetime(2026, 10, 3, 23, 30, tzinfo=NEW_YORK)  # 03:30 UTC next day
    book = Book.objects.create(title="Dune", price=Decimal("9.99"), published_at=stored)
    with connection.cursor() as cursor:
        cursor.execute("SELECT published_at FROM catalog_book WHERE id = %s", [book.pk])
        self.assertEqual(cursor.fetchone()[0], datetime.datetime(2026, 10, 4, 3, 30))  # naive, in UTC
    template = Template("{% load tz %}{{ b.published_at }}|{{ b.published_at|timezone:'Asia/Tokyo' }}")
    with timezone.override(PARIS):
        book.refresh_from_db()
        text = template.render(Context({"b": book}))
    self.assertTrue(text.startswith("Oct. 4, 2026, 5:30 a.m."), text)
    self.assertTrue(text.endswith("12:30 p.m."), text)

@override_settings(TIME_ZONE="Europe/Paris")
def test_date_lookup_and_truncdate_use_current_zone(self):
    Book.objects.create(title="Late", price=Decimal("1"),
                        published_at=datetime.datetime(2026, 10, 3, 23, 30, tzinfo=UTC))  # Oct 4 in Paris
    self.assertEqual(Book.objects.filter(published_at__date=datetime.date(2026, 10, 4)).count(), 1)
    days = Book.objects.annotate(day=TruncDate("published_at")).values("day").annotate(n=Count("pk"))
    self.assertEqual(list(days), [{"day": datetime.date(2026, 10, 4), "n": 1}])
    with timezone.override(datetime.timezone.utc):
        self.assertEqual(Book.objects.filter(published_at__date=datetime.date(2026, 10, 3)).count(), 1)

import warnings

warnings.filterwarnings(
    "error",
    r"DateTimeField .* received a naive datetime",
    RuntimeWarning,
    r"django\.db\.models\.fields",
)

def test_naive_datetime_warns_and_uses_default_zone(self):
    with warnings.catch_warnings(record=True) as caught:
        warnings.simplefilter("always")
        book = Book.objects.create(title="Naive", price=Decimal("1"),
                                   published_at=datetime.datetime(2026, 1, 1, 12, 0))
    self.assertTrue(any("received a naive datetime" in str(w.message) for w in caught))
    book.refresh_from_db()
    self.assertEqual(book.published_at, datetime.datetime(2026, 1, 1, 12, 0, tzinfo=UTC))

def test_naive_aware_comparison_error(self):
    aware = timezone.now()
    naive = timezone.make_naive(aware)
    with self.assertRaisesMessage(TypeError, "can't compare offset-naive and offset-aware datetimes"):
        naive == aware or naive < aware

def test_form_interprets_input_in_current_zone(self):
    with timezone.override(PARIS):
        form = BookForm({"title": "Dune", "price": "10.00", "published_at": "2026-10-03 14:30"})
        self.assertTrue(form.is_valid(), form.errors)
        self.assertEqual(form.cleaned_data["published_at"], datetime.datetime(2026, 10, 3, 12, 30, tzinfo=UTC))

def test_form_rejects_nonexistent_local_time(self):
    with timezone.override(NEW_YORK):
        form = BookForm({"title": "Dune", "price": "10.00", "published_at": "2026-03-08 02:30"})
        self.assertFalse(form.is_valid())

import datetime
import zoneinfo

from django.utils import timezone

paris_tz = zoneinfo.ZoneInfo("Europe/Paris")
new_york_tz = zoneinfo.ZoneInfo("America/New_York")
paris = datetime.datetime(2012, 3, 3, 1, 30, tzinfo=paris_tz)
new_york = paris.astimezone(new_york_tz)
print(paris == new_york, paris.date() == new_york.date())

timezone.activate(zoneinfo.ZoneInfo("Asia/Singapore"))
local = paris.astimezone(timezone.get_current_timezone())
print(local, local.date())
timezone.deactivate()

True False
2012-03-03 08:30:00+08:00 2012-03-03