Getting the correct timezone offset in Python using local timezone

Question

Ok let me first start by saying my timezone is CET/CEST. The exact moment it changes from CEST to CET (back from DST, which is GMT+2, to normal, which GMT+1, thus) is always the last Sunday of October at 3AM. In 2010 this was 31 October 3AM.

Now note the following:

>>> import datetime >>> import pytz.reference >>> local_tnz = pytz.reference.LocalTimezone() >>> local_tnz.utcoffset(datetime.datetime(2010, 10, 31, 2, 12, 30)) datetime.timedelta(0, 3600) 

This is wrong as explained above.

>>> local_tnz.utcoffset(datetime.datetime(2010, 10, 30, 2, 12, 30)) datetime.timedelta(0, 7200) >>> local_tnz.utcoffset(datetime.datetime(2010, 10, 31, 2, 12, 30)) datetime.timedelta(0, 7200) 

Now it is suddenly correct :/

I know there are several questions about this already, but the solution given is always "use localize", but my problem here is that the LocalTimezone does not provide that method.

In fact, I have several timestamps in milliseconds of which I need the utcoffset of the local timezone (not just mine, but of anyone using the program). One of these is 1288483950000 or Sun Oct 31 2010 02:12:30 GMT+0200 (CEST) in my timezone.

Currently I do the following to get the datetime object:

datetime.datetime.fromtimestamp(int(int(millis)/1E3))  

and this to get the utcoffset in minutes:

-int(local_tnz.utcoffset(date).total_seconds()/60) 

which, unfortunately, is wrong in many occasions :(.

Any ideas?

Note: I'm using python3.2.4, not that it should matter in this case.

EDIT:

Found the solution thanks to @JamesHolderness:

def datetimeFromMillis(millis):     return pytz.utc.localize(datetime.datetime.utcfromtimestamp(int(int(millis)/1E3)))  def getTimezoneOffset(date):     return -int(date.astimezone(local_tz).utcoffset().total_seconds()/60) 

With local_tz equal to tzlocal.get_localzone() from the tzlocal module.

Answer 1

According to Wikipedia, the transition to and from Summer Time occurs at 01:00 UTC.

• At 00:12 UTC you are still in Central European Summer Time (i.e. UTC+02:00), so the local time is 02:12.

• At 01:12 UTC you are back in the standard Central European Time (i.e. UTC+01:00), so the local time is again 02:12.

When changing from Summer Time back to standard time, the local time goes from 02:59 back to 02:00 and the hour repeats itself. So when asking for the UTC offset of 02:12 (local time), the answer could truthfully be either +01:00 or +02:00 - it depends which version of 02:12 you are talking about.

On further investigation of the pytz library, I think your problem may be that you shouldn't be using the pytz.reference implementation, which may not deal with these ambiguities very well. Quoting from the comments in the source code:

Reference tzinfo implementations from the Python docs. Used for testing against as they are only correct for the years 1987 to 2006. Do not use these for real code.

Working with ambiguous times in pytz

What you should be doing is constructing a timezone object for the appropriate timezone:

import pytz cet = pytz.timezone('CET') 

Then you can use the utcoffset method to calculate the UTC offset of a date/time in that timezone.

dt = datetime.datetime(2010, 10, 31, 2, 12, 30) offset = cet.utcoffset(dt) 

Note, that the above example will throw an AmbiguousTimeError exception, because it can't tell which of the two versions of 02:12:30 you meant. Fortunately pytz will let you specify whether you want the dst version or the standard version by setting the is_dst parameter. For example:

offset = cet.utcoffset(dt, is_dst = True) 

Note that it doesn't harm to set this parameter on all calls to utcoffset, even if the time wouldn't be ambiguous. According to the documentation, it is only used during DST transition ambiguous periods to resolve that ambiguity.

How to deal with timestamps

As for dealing with timestamps, it's best you store them as UTC values for as long as possible, otherwise you potentially end up throwing away valuable information. So first convert to a UTC datetime with the datetime.utcfromtimestamp method.

dt = datetime.datetime.utcfromtimestamp(1288483950) 

Then use pytz to localize the time as UTC, so the timezone is attached to the datetime object.

dt = pytz.utc.localize(dt) 

Finally you can convert that UTC datetime into your local timezone, and obtain the timezone offset like this:

offset = dt.astimezone(cet).utcoffset() 

Note that this set of calculations will produce the correct offsets for both 1288483950 and 1288487550, even though both timestamps are represented by 02:12:30 in the CET timezone.

Determining the local timezone

If you need to use the local timezone of your computer rather than a fixed timezone, you can't do that from pytz directly. You also can't just construct a pytz.timezone object using the timezone name from time.tzname, because the names won't always be recognised by pytz.

The solution is to use the tzlocal module - its sole purpose is to provide this missing functionality in pytz. You use it like this:

import tzlocal local_tz = tzlocal.get_localzone() 

The get_localzone() function returns a pytz.timezone object, so you should be able to use that value in all the places I've used the cet variable in the examples above.