title: django.utils.timezone Example Code
category: page
slug: django-utils-timezone-examples
sortorder: 500013715
toc: False
sidebartitle: django.utils.timezone
meta: Python code examples for timezone-related classes and functions provided by the Django codebase. 


[timezone.py](https://github.com/django/django/blob/master/django/utils/timezone.py)
is a source file within the [Django](/django.html) project that contains
date and time-related helper classes and functions that are useful when 
building web applications.


## Example 1 from django-cms
[django-cms](https://github.com/divio/django-cms)
([project website](https://www.django-cms.org/en/)) is a Python-based
content management system (CMS) [library](https://pypi.org/project/django-cms/) 
for use with Django web apps that is open sourced under the 
[BSD 3-Clause "New" License](https://github.com/divio/django-cms/blob/develop/LICENSE).

[**django-cms/cms/models/query.py**](https://github.com/divio/django-cms/blob/develop/cms/models/query.py)

```python
# -*- coding: utf-8 -*-
from django.db.models import Q
~~from django.utils import timezone

from treebeard.mp_tree import MP_NodeQuerySet

from cms.publisher.query import PublisherQuerySet
from cms.exceptions import NoHomeFound


class PageQuerySet(PublisherQuerySet):

    def on_site(self, site=None):
        from cms.utils import get_current_site

        if site is None:
            site = get_current_site()
        return self.filter(node__site=site)

    def published(self, site=None, language=None):
~~        now = timezone.now()
        if language:
~~            pub = self.on_site(site).filter(
~~                Q(publication_date__lte=now) | \
~~                Q(publication_date__isnull=True),
~~                Q(publication_end_date__gt=now) | \
~~                Q(publication_end_date__isnull=True),
~~                title_set__published=True, title_set__language=language,
            )
        else:
~~            pub = self.on_site(site).filter(
~~                Q(publication_date__lte=now) | \
~~                Q(publication_date__isnull=True),
~~                Q(publication_end_date__gt=now) | \
~~                Q(publication_end_date__isnull=True),
~~                title_set__published=True,
            )
        return pub.exclude(title_set__publisher_state=4)
```


## Example 2 from django-smithy
[django-smithy](https://github.com/jamiecounsell/django-smithy) is
a [Django](/django.html) code library that allows users to send 
HTTP requests from the Django admin user interface. The code for
the project is open source under the 
[MIT license](https://github.com/jamiecounsell/django-smithy/blob/master/LICENSE).

[**django-smithy/smithy/migrations/0001_initial.py**](https://github.com/jamiecounsell/django-smithy/blob/master/smithy/migrations/0001_initial.py)

```python
# Generated by Django 2.1.5 on 2019-03-16 20:32

from django.db import migrations, models
import django.db.models.deletion
~~import django.utils.timezone
import model_utils.fields


class Migration(migrations.Migration):

    initial = True

    dependencies = [
    ]

    operations = [
        migrations.CreateModel(
            name='Cookie',
            fields=[
                ('id', models.AutoField(auto_created=True, 
                                        primary_key=True, serialize=False, 
                                        verbose_name='ID')),
~~                ('created', model_utils.fields.AutoCreatedField(\
~~                   default=django.utils.timezone.now, editable=False, 
~~                    verbose_name='created')),
~~                ('modified', model_utils.fields.AutoLastModifiedField(\
~~                   default=django.utils.timezone.now, editable=False, 
~~                   verbose_name='modified')),
                ('name', models.CharField(max_length=200)),
                ('value', models.TextField()),
            ],
            options={
                'abstract': False,
            },
        ),
        migrations.CreateModel(
            name='Header',
            fields=[
                ('id', models.AutoField(auto_created=True, 
                                        primary_key=True, 
                                        serialize=False, 
                                        verbose_name='ID')),
~~                ('created', model_utils.fields.AutoCreatedField(\
~~                 default=django.utils.timezone.now, editable=False, 
~~                 verbose_name='created')),
~~                ('modified', model_utils.fields.AutoLastModifiedField(\
~~                 default=django.utils.timezone.now, editable=False, 
~~                 verbose_name='modified')),
                ('name', models.CharField(max_length=200)),
                ('value', models.TextField()),
            ],
            options={
                'abstract': False,
            },
        ),
        migrations.CreateModel(
            name='QueryParameter',
            fields=[
                ('id', models.AutoField(auto_created=True, 
                                        primary_key=True, 
                                        serialize=False, 
                                        verbose_name='ID')),
~~                ('created', model_utils.fields.AutoCreatedField(\
~~                 default=django.utils.timezone.now, editable=False, 
~~                 verbose_name='created')),
~~                ('modified', model_utils.fields.AutoLastModifiedField(\
~~                 default=django.utils.timezone.now, editable=False, 
~~                 verbose_name='modified')),
                ('name', models.CharField(max_length=200)),
                ('value', models.TextField()),
            ],
            options={
                'abstract': False,
            },
        ),
```


## Example 3 from django-easy-timezones
[django-easy-timezones](https://github.com/Miserlou/django-easy-timezones)
([project website](https://www.gun.io/blog/django-easy-timezones))
is a [Django](/django.html) 
[middleware](https://docs.djangoproject.com/en/stable/topics/http/middleware/)
[code library](https://pypi.org/project/django-easy-timezones/)
to simplify handling time data in your applications using
users' geolocation data.

[**django-easy-timezones/easy_timezones/middleware.py**](https://github.com/Miserlou/django-easy-timezones/blob/master/easy_timezones/middleware.py)

```python
import django
from django.conf import settings
from django.contrib.auth import get_user_model
from django.core.exceptions import ImproperlyConfigured
~~from django.utils import timezone
import pytz
import pygeoip
import os

from .signals import detected_timezone
from .utils import get_ip_address_from_request, is_valid_ip, is_local_ip


db_loaded = False
db = None
db_v6 = None

def load_db_settings():
    GEOIP_DATABASE = getattr(settings, 'GEOIP_DATABASE', 'GeoLiteCity.dat')

    if not GEOIP_DATABASE:
        raise ImproperlyConfigured("GEOIP_DATABASE setting has not been " + \
                                   "properly defined.")

    if not os.path.exists(GEOIP_DATABASE):
        raise ImproperlyConfigured("GEOIP_DATABASE setting is defined, " + \
                                   "but file does not exist.")

    GEOIPV6_DATABASE = getattr(settings, 'GEOIPV6_DATABASE', 
                               'GeoLiteCityv6.dat')

    if not GEOIPV6_DATABASE:
        raise ImproperlyConfigured("GEOIPV6_DATABASE setting has not " + \
                                   "been properly defined.")

    if not os.path.exists(GEOIPV6_DATABASE):
        raise ImproperlyConfigured("GEOIPV6_DATABASE setting is " + \
                                   "defined, but file does not exist.")

    return (GEOIP_DATABASE, GEOIPV6_DATABASE)

load_db_settings()

def load_db():

    GEOIP_DATABASE, GEOIPV6_DATABASE = load_db_settings()

    global db
    db = pygeoip.GeoIP(GEOIP_DATABASE, pygeoip.MEMORY_CACHE)

    global db_v6
    db_v6 = pygeoip.GeoIP(GEOIPV6_DATABASE, pygeoip.MEMORY_CACHE)

    global db_loaded
    db_loaded = True


if django.VERSION >= (1, 10):
    from django.utils.deprecation import MiddlewareMixin
    middleware_base_class = MiddlewareMixin
else:
    middleware_base_class = object


class EasyTimezoneMiddleware(middleware_base_class):
    def process_request(self, request):
        """
        If we can get a valid IP from the request,
        look up that address in the database to get the appropriate 
        timezone and activate it. Else, use the default.
        """

        if not request:
            return

        if not db_loaded:
            load_db()

        tz = request.session.get('django_timezone')

        if not tz:
            # use the default timezone (settings.TIME_ZONE) for localhost
~~            tz = timezone.get_default_timezone()

            client_ip = get_ip_address_from_request(request)
            ip_addrs = client_ip.split(',')
            for ip in ip_addrs:
                if is_valid_ip(ip) and not is_local_ip(ip):
                    if ':' in ip:
                        tz = db_v6.time_zone_by_addr(ip)
                        break
                    else:
                        tz = db.time_zone_by_addr(ip)
                        break

        if tz:
~~            timezone.activate(tz)
            request.session['django_timezone'] = str(tz)
            if getattr(settings, 'AUTH_USER_MODEL', 
                       None) and getattr(request, 'user', None):
~~                detected_timezone.send(sender=get_user_model(), 
~~                                       instance=request.user, 
~~                                       timezone=tz)
        else:
~~            timezone.deactivate()
```


## Example 4 from AuditLog
[Auditlog](https://github.com/jjkester/django-auditlog) 
([project documentation](https://django-auditlog.readthedocs.io/en/latest/))
is a [Django](/django.html) app that logs changes to Python objects,
similar to the Django admin's logs but with more details and
output formats. Auditlog's source code is provided as open source under the
[MIT license](https://github.com/jjkester/django-auditlog/blob/master/LICENSE).

[**django-auditlog / src / auditlog / diff.py**](https://github.com/jjkester/django-auditlog/blob/master/src/auditlog/diff.py)

```python
from __future__ import unicode_literals

from django.conf import settings
from django.core.exceptions import ObjectDoesNotExist
from django.db.models import Model, NOT_PROVIDED, DateTimeField
~~from django.utils import timezone
from django.utils.encoding import smart_text


def track_field(field):
    """
    Returns whether the given field should be tracked by Auditlog.
    Untracked fields are many-to-many relations and relations to 
    the Auditlog LogEntry model.
    :param field: The field to check.
    :type field: Field
    :return: Whether the given field should be tracked.
    :rtype: bool
    """
    from auditlog.models import LogEntry
    # Do not track many to many relations
    if field.many_to_many:
        return False

    # Do not track relations to LogEntry
    if getattr(field, 'remote_field', None) is not None and \
        field.remote_field.model == LogEntry:
        return False

    # 1.8 check
    elif getattr(field, 'rel', None) is not None and \
        field.rel.to == LogEntry:
        return False

    return True


def get_fields_in_model(instance):
    """
    Returns the list of fields in the given model instance. 
    Checks whether to use the official _meta API or use the raw
    data. This method excludes many to many fields.
    :param instance: The model instance to get the fields for
    :type instance: Model
    :return: The list of fields for the given model (instance)
    :rtype: list
    """
    assert isinstance(instance, Model)

    # Check if the Django 1.8 _meta API is available
    use_api = hasattr(instance._meta, 'get_fields') and \
              callable(instance._meta.get_fields)

    if use_api:
        return [f for f in instance._meta.get_fields() if track_field(f)]
    return instance._meta.fields


def get_field_value(obj, field):
    """
    Gets the value of a given model instance field.
    :param obj: The model instance.
    :type obj: Model
    :param field: The field you want to find the value of.
    :type field: Any
    :return: The value of the field as a string.
    :rtype: str
    """
    if isinstance(field, DateTimeField):
        # DateTimeFields are timezone-aware, so we need 
        # to convert the field to its naive form before we 
        # can accuratly compare them for changes.
~~        try:
~~            value = field.to_python(getattr(obj, field.name, 
~~                                    None))
~~            if value is not None and settings.USE_TZ and \
~~                not timezone.is_naive(value):
~~                value = timezone.make_naive(value, 
~~                                            timezone=timezone.utc)
        except ObjectDoesNotExist:
            value = field.default if field.default \
                is not NOT_PROVIDED else None
    else:
        try:
            value = smart_text(getattr(obj, field.name, None))
        except ObjectDoesNotExist:
            value = field.default if field.default \
                is not NOT_PROVIDED else None

    return value

## ... source file continues here without further timezone examples ...
```
