""" 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()