DateTimeSyncer with Daylight Savings Time adjustment (Python recipe) by Jack Trainor

ActiveState Code (http://code.activestate.com/recipes/576546/)

"""
DateTimeSyncer with Daylight Savings Time adjustment

Synchronizes computer's current date and time with Daylight Savings adjustment
directly without depending on operating system or Python's time.localtime().

This allows programmers to update Daylight Savings Time rules without
depending on external updates to OS or Python.

Double-clicking  this module will synchronize your computer's date and time on a Windows machine.  

Jack Trainor 2008
"""
import socket
import struct
import os
import sys
import time
import calendar

# ==============================================================================
# Constants
# ==============================================================================
SNTP_SERVER = "usno.pa-x.dec.com"  # substitute other servers as desired
SNTP_PORT = 123

TIME_1970 = 2208988800L 

MINUTE_SECONDS = 60
HOUR_SECONDS = 60 * MINUTE_SECONDS
DAY_SECONDS = 24 * HOUR_SECONDS
WEEK_SECONDS = 7 * DAY_SECONDS

JAN = 1
FEB = 2
MAR = 3
APR = 4
MAY = 5
JUN = 6
JUL = 7
AUG = 8
SEP = 9
OCT = 10
NOV = 11
DEC = 12

MON = 0
TUE = 1
WED = 2
THU = 3
FRI = 4
SAT = 5
SUN = 6

UNIVERSAL = "Universal"
EASTERN = "Eastern"
CENTRAL = "Central"
MOUNTAIN = "Mountain"
PACIFIC = "Pacific"

TIME_ZONE_OFFSETS_TO_UTC = { 
    UNIVERSAL: 0, 
    EASTERN: 5 * HOUR_SECONDS, 
    CENTRAL: 6 * HOUR_SECONDS, 
    MOUNTAIN: 7 * HOUR_SECONDS, 
    PACIFIC: 8 * HOUR_SECONDS 
    }

# ==============================================================================
# Time utilities
# ==============================================================================
def secs_to_tuple(secs):
    """ Convert seconds to time tuple in UTC. """
    return time.gmtime(secs)
    
def tuple_to_secs(tuple):
    """ Convert time tuple to UTC seconds. """
    return calendar.timegm(tuple)

def fill_in_tuple(tuple):
    """ Ensure that all tuple fields are filled in as completely as possible. """
    secs = tuple_to_secs(tuple)
    out_tuple = secs_to_tuple(secs)
    return out_tuple

def local_tuple_to_utc_secs(time_tuple, timezone=UNIVERSAL, is_dst=False):
    """ Convert time tuple with timezone and DST info to UTC seconds. """
    """ NOTE: It's up to caller that is_dst flag makes sense. """
    time_tuple = fill_in_tuple(time_tuple)
    secs = tuple_to_secs(time_tuple)
    secs += TIME_ZONE_OFFSETS_TO_UTC[timezone]
    if is_dst:
        secs -= HOUR_SECONDS
    return secs

def local_tuple_to_utc_tuple(time_tuple, timezone=UNIVERSAL, is_dst=False):
    """ Convert time tuple with timezone and DST info to UTC tuple. """
    """ NOTE: It's up to caller that is_dst flag makes sense. """
    utc_secs = local_tuple_to_utc_secs(time_tuple, timezone, is_dst)
    utc_tuple = secs_to_tuple(utc_secs)
    return secs

def utc_tuple_to_local_secs(utc_tuple, output_timezone=UNIVERSAL, is_dst=False):
    """ Convert UTC time tuple to seconds according to timezone and is_dst. """
    """ NOTE: It's up to caller that is_dst flag makes sense. """
    utc_tuple = fill_in_tuple(utc_tuple)
    secs = tuple_to_secs(utc_tuple)
    secs -= TIME_ZONE_OFFSETS_TO_UTC[timezone]
    if is_dst:
        secs += HOUR_SECONDS
    return secs

def utc_tuple_to_local_tuple(utc_tuple, output_timezone=UNIVERSAL, is_dst=False):
    """ Convert UTC time tuple to tuple in terms of timezone and is_dst. """
    """ NOTE: It's up to caller that is_dst flag makes sense. """
    local_secs = utc_tuple_to_local_secs(utc_tuple, output_timezone, is_dst)
    return secs_to_tuple(local_secs)            

def debug_secs(secs):
    return "%d: %s" % (secs, time.asctime(secs_to_tuple(secs)))

def debug_tuple(tuple):
    return "%s: %s" % (tuple, time.asctime(tuple))


# ==============================================================================
# Daylight Savings Time functions
# ==============================================================================
def calc_DST_utc_secs(start_tuple, timezone=UNIVERSAL, is_dst=False, weekday=SUN):
    """ Calculate DST transition in UTC seconds. DST can be specified as the 
    first weekday (usually Sunday) after a date and time in a local time zone. """
    start_tuple = fill_in_tuple(start_tuple)
    utc_secs = local_tuple_to_utc_secs(start_tuple, timezone, is_dst)
    utc_tuple = secs_to_tuple(utc_secs)
    
    # Walk to first day on or after start day that corresponds to weekday.
    # Compensate in case weekday changes in conversion to UTC.
    weekday = ((weekday + utc_tuple[6] - start_tuple[6]) % 7)
    while True:
        if utc_tuple[6] == weekday:
            break
        utc_secs += DAY_SECONDS
        utc_tuple = secs_to_tuple(utc_secs)
    return utc_secs

def calc_DST_start_utc_secs(year, timezone):
    """ Calculates start of US Daylight Savings Time for year and timezone. """
    if year <= 2006:
        return calc_DST_utc_secs((year, APR, 1, 2, 0, 0, 0, 0, 0), timezone)
    else:
        return calc_DST_utc_secs((year, MAR, 8, 2, 0, 0, 0, 0, 0), timezone)
        
def calc_DST_end_utc_secs(year, timezone):
    """ Calculates end of US Daylight Savings Time for year and timezone. """
    if year <= 2006:
        return calc_DST_utc_secs((year, OCT, 25, 2, 0, 0, 0, 0, 0), timezone, True)
    else:
        return calc_DST_utc_secs((year, NOV, 1, 2, 0, 0, 0, 0, 0), timezone, True)


# ==============================================================================
# get_current_SNTP_time
# ==============================================================================
def get_current_SNTP_time(sntp_server=SNTP_SERVER):
    """ Acquires current time in UTC secs from SNTP server. """
    """ Thanks to Simon Foster's "Simple (very) SNTP client" recipe:
    http://code.activestate.com/recipes/117211/ """
    try:
        client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        data = '\x1b' + 47 * '\0'
        client.sendto(data, (sntp_server, SNTP_PORT))
        data, address = client.recvfrom(1024)
        if data:
            utc_secs = struct.unpack('!12I', data)[10]
            utc_secs -= TIME_1970
            return utc_secs
    except Exception, e:
        print "get_current_SNTP_time failed:", sntp_server
    return None
    
    
# ==============================================================================
# OS_set_datetime
# ==============================================================================
def Windows_set_datetime(dt):
    """ Uses DateTime instance to set OS date and time for Windows computer. """
    print "date %d/%d/%d" % (dt.month(), dt.date(), dt.year())
    print "time %d:%d:%d" % (dt.hour(), dt.minutes(), dt.seconds())
    os.system("date %d/%d/%d" % (dt.month(), dt.date(), dt.year()))
    os.system("time %d:%d:%d" % (dt.hour(), dt.minutes(), dt.seconds()))
    
def Linux_set_datetime(dt):
    """ Uses DateTime instance to set OS date and time for Linux computer. """
    """ NOTE: untested, presumes root privileges """
    os.system("date %d%d%d%d%d" % (dt.month(), dt.date(), dt.hour(), dt.seconds(),dt.year()))
    os.system("hwclock --utc --systohc")


# ==============================================================================
# class DateTime
# ==============================================================================
class DateTime(object):
    """ DateTime provides simple conversion of a time in UTC seconds to a
    time tuple expressed in another time zone including compensation for
    Daylight Savings Time. 
    
    * All calculations are based on __utc_secs.
    * __output_tuple is recalculated each time _utc_secs or _output_timezone changes.
    * isdst tuple field is ignored.
    * tuple fields are accessed by index for compatibility with older Pythons.
    * tuple fields are wrapped by DateTime field methods. 
    """
    def __init__(self, utc_secs=0, output_timezone=UNIVERSAL):
        self.__utc_secs = 0
        self.__output_tuple = None
        self.set_by_utc_secs(utc_secs, output_timezone)
        
    def set_by_utc_secs(self, utc_secs, output_timezone=UNIVERSAL):
        self.__utc_secs = utc_secs
        self.set_output_timezone(output_timezone)
        return self

    def set_output_timezone(self, output_timezone):
        self.__output_timezone = output_timezone
        self.calc_output_tuple()
        return self

    def calc_output_tuple(self):
        utc_secs = self.__utc_secs
        utc_tuple = secs_to_tuple(utc_secs)
        year = utc_tuple[0]
        self.is_dst = False
        timezone = self.__output_timezone
        output_secs = utc_secs - TIME_ZONE_OFFSETS_TO_UTC[timezone]
        if timezone != UNIVERSAL:
            dst_start = calc_DST_start_utc_secs(year, timezone)
            dst_end = calc_DST_end_utc_secs(year, timezone)
            if (utc_secs >= dst_start and utc_secs <= dst_end):
                output_secs += HOUR_SECONDS
                self.is_dst = True
        self.__output_tuple = secs_to_tuple(output_secs)
        self.db_output = time.asctime(self.__output_tuple)
        return self

    def set_utc_secs(self, utc_secs):
        self.__utc_secs = utc_secs
        self.__timezone = UNIVERSAL
        self.__output_tuple = secs_to_tuple(utc_secs)
        return self
        
    def offset_secs(self, secs):
        self.__utc_secs += secs
        self.__output_tuple()
        return self
        
    def output_tuple(self):
        return self.__output_tuple
    
    def utc_secs(self):
        return self.__utc_secs
    
    def year(self):
        return self.__output_tuple[0]
    
    def month(self):
        return self.__output_tuple[1]
    
    def date(self):
        return self.__output_tuple[2]
    
    def hour(self):
        return self.__output_tuple[3]
    
    def minutes(self):
        return self.__output_tuple[4]
    
    def seconds(self):
        return self.__output_tuple[5]
    
    def weekday(self):
        return self.__output_tuple[6]
    
    def yearday(self):
        return self.__output_tuple[6]
    
# ==============================================================================
# class DateTimeSyncer
# ==============================================================================
class DateTimeSyncer(object):
    """ DateTimeSyncer acquires current time from an SNTP servers, converts
    that time to a DateTime instance adjusted to Daylight Savings time
    of specified timezone. 
    
    Example: DateTimeSyncer(PACIFIC).execute() 
    """
    def __init__(self, timezone, sntp_server=SNTP_SERVER):
        self.sntp_server = sntp_server
        self.timezone = timezone
    
    def execute(self, set_date_time_func=Windows_set_datetime, pause=False):
        """ Perform time synchronization. """
        """ For other non-Windows platforms, write corresponding function 
        set_date_time_func and pass it in. """
        utc_secs = get_current_SNTP_time(self.sntp_server)
        if utc_secs:
            dt = DateTime(utc_secs, self.timezone)
            set_date_time_func(dt)
            print "DateTimeSyncer succesful."
        else:
            print "DateTimeSyncer failed."
        if pause:
            raw_input("Press a key...")
            
def test():
    ds_start_minus1_dt = DateTime(calc_DST_start_utc_secs(2008, PACIFIC)-1, PACIFIC)
    print "DST start-1s:", debug_tuple(ds_start_minus1_dt.output_tuple())   
    ds_start_dt = DateTime(calc_DST_start_utc_secs(2008, PACIFIC), PACIFIC)
    print "DST start:", debug_tuple(ds_start_dt.output_tuple())
    ds_start_plus_dt = DateTime(calc_DST_start_utc_secs(2008, PACIFIC)+1, PACIFIC)
    print "DST start+1s:", debug_tuple(ds_start_plus_dt.output_tuple())
    print
    ds_end_minus1_dt = DateTime(calc_DST_end_utc_secs(2008, PACIFIC)-1, PACIFIC)
    print "DST end-1s:", debug_tuple(ds_end_minus1_dt.output_tuple())
    ds_end_dt = DateTime(calc_DST_end_utc_secs(2008, PACIFIC), PACIFIC)
    print "DST end:", debug_tuple(ds_end_dt.output_tuple())
    ds_end_plus_dt = DateTime(calc_DST_end_utc_secs(2008, PACIFIC)+1, PACIFIC)
    print "DST end+1s:", debug_tuple(ds_end_plus_dt.output_tuple())
    print
    
if __name__ == '__main__': 
    #test()
    DateTimeSyncer(PACIFIC).execute()