#!/usr/bin/python
#
# Copyright 2008 Google Inc. All Rights Reserved.
"""
A test app for converting datetimes between timezones and storing and
retrieving them from the datastore.
"""
__author__ = 'ryanb@google.com (Ryan Barrett)'
from google.appengine.ext import webapp
from google.appengine.api import datastore
import calendar
import datetime
import os
import pytz
import sys
import time
import wsgiref.handlers
HTML = """
Time zones in Google App Engine
Time zones in Google App Engine
Use this to try out time zone handling in the
Google App Engine runtime and
datastore. See the
DateTimeProperty docs for details.
You can also download this app's source.
The runtime's TZ environment variable is set to
UTC, and can't be changed. Timestamps returned by e.g.
time.time()
and
datetime.datetime.now()
will always be in UTC.
Similarly,
datetime
properties in the datastore will always be stored and returned as UTC.
You can change the time zone of a datetime in memory with the
astimezone()
method. If datetime's
tzinfo
member isn't set, you'll first need to set it to a UTC tzinfo
with the
replace()
method.
The third-party
pytz
module has a comprehensive set of tzinfo classes. If your app has
complex time zone needs, consider including it with your app's code. It's
heavyweight, though - over 500 files! - so if you have simpler needs, consider
writing just the few tzinfo classes you need by hand, following
the spec.
In the table below, if a datetime has a +HH:MM or
-HH:MM suffix, e.g. +00:00 for UTC, that means it
has a tzinfo (an explicit time zone) attached. Also, assume
utc is a tzinfo for the UTC time zone, and assume
the Foo class has this definition:
class Foo(db.Model):
timestamp = db.DateTimeProperty(auto_now=True)
os.environ['TZ'] |
%(env_tz)s |
time.time() |
%(time_time)s |
datetime.now() |
%(datetime_now)s |
Foo().put().timestamp |
%(after_put)s |
| Raw timestamp in datastore |
%(raw_timestamp)s |
datetime.fromtimestamp(raw_timestamp, utc) |
%(raw_datetime)s |
Foo.get(foo_key).timestamp |
%(after_get)s |
%(translate_code)s |
%(translated)s |
"""
class UtcTzinfo(datetime.tzinfo):
def utcoffset(self, dt): return datetime.timedelta(0)
def dst(self, dt): return datetime.timedelta(0)
def tzname(self, dt): return 'UTC'
def olsen_name(self): return 'UTC'
class EstTzinfo(datetime.tzinfo):
def utcoffset(self, dt): return datetime.timedelta(hours=-5)
def dst(self, dt): return datetime.timedelta(0)
def tzname(self, dt): return 'EST+05EDT'
def olsen_name(self): return 'US/Eastern'
class PstTzinfo(datetime.tzinfo):
def utcoffset(self, dt): return datetime.timedelta(hours=-8)
def dst(self, dt): return datetime.timedelta(0)
def tzname(self, dt): return 'PST+08PDT'
def olsen_name(self): return 'US/Pacific'
TZINFOS = {
'utc': UtcTzinfo(),
'est': EstTzinfo(),
'pst': PstTzinfo(),
}
class App(webapp.RequestHandler):
def get(self):
env_tz = os.environ.get('TZ', 'not set')
# calculate result datetimes
time_time = time.time()
datetime_now = datetime.datetime.now()
entity = datastore.Entity('Datetime')
entity['datetime'] = datetime_now
datastore.Put(entity)
after_put = entity['datetime']
raw_timestamp = \
float(entity._ToPb().property(0).value().int64value()) / 1000000
raw_datetime = \
datetime.datetime.fromtimestamp(raw_timestamp, TZINFOS['utc'])
got = datastore.Get(entity)
after_get = got['datetime']
translate_code, translated = self.translate(after_get)
# render
template_vars = locals()
template_vars.update(dict(('translate_to_%s_selected' % to, '')
for to in ('nothing', 'utc', 'pst', 'est')))
template_vars['translate_to_%s_selected' %
self.request.get('translate_to')] = 'selected="selected"'
template_vars.update(dict(('translate_with_%s_selected' % with_, '')
for with_ in ('nothing', 'astimezone',
'pytz', 'environ')))
template_vars['translate_with_%s_selected' %
self.request.get('translate_with')] = 'selected="selected"'
self.response.out.write(HTML % template_vars)
def translate(self, timestamp):
"""Translates a UTC datetime to the env_tz query parameter's time zone.
Args:
timestamp: A datetime instance.
Returns:
A (str, datetime) tuple. The string is the code snippet used to
translate the timestamp, and the datetime is the result.
"""
translate_to = self.request.get('translate_to', 'nothing')
translate_with = self.request.get('translate_with', 'astimezone()')
utc = TZINFOS['utc']
if translate_to == 'nothing':
return ('no translation', 'N/A')
elif translate_with == 'astimezone':
timestamp = timestamp.replace(tzinfo=utc)
return ('timestamp.astimezone(to_tzinfo)',
timestamp.astimezone(TZINFOS[translate_to]))
elif translate_with == 'pytz':
timestamp = timestamp.replace(tzinfo=utc)
olsen_name = TZINFOS[translate_to].olsen_name()
return ('timestamp.astimezone(pytz.timezone(%r))' % olsen_name,
timestamp.astimezone(pytz.timezone(olsen_name)))
elif translate_with == 'environ':
# won't work; for example only
os.environ['TZ'] = utc.tzname(False)
time.tzset()
return ("""os.environ['TZ'] = '%s'
time.tzset()
time.ctime(raw_timestamp)""" % os.environ['TZ'],
time.ctime(calendar.timegm(timestamp.timetuple())))
else:
return ('invalid translation', 'invalid translation')
def main(argv):
application = webapp.WSGIApplication([('/', App)], debug=True)
wsgiref.handlers.CGIHandler().run(application)
if __name__ == '__main__':
main(sys.argv)