django.utils.timezone Example Code

timezone.py is a source file within the Django 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 (project website) is a Python-based content management system (CMS) library for use with Django web apps that is open sourced under the BSD 3-Clause "New" License.

django-cms/cms/models/query.py

# -*- 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 is a Django 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.

django-smithy/smithy/migrations/0001_initial.py

# 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 (project website) is a Django middleware code library to simplify handling time data in your applications using users' geolocation data.

django-easy-timezones/easy_timezones/middleware.py

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 (project documentation) is a Django 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.

django-auditlog / src / auditlog / diff.py

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 ...

Full Stack Python

Full Stack Python is an open book that explains concepts in plain language and provides helpful resources for those topics.
Updates via Twitter & Facebook.

Matt Makai 2012-2019