"""Concrete date/time and related types -- prototype implemented in Python.

See http://www.zope.org/Members/fdrake/DateTimeWiki/FrontPage

See also http://dir.yahoo.com/Reference/calendars/

For a primer on DST, including many current DST rules, see

http://webexhibits.org/daylightsaving/

For more about DST than you ever wanted to know, see

ftp://elsie.nci.nih.gov/pub/

Sources for time zone and DST data: http://www.twinsun.com/tz/tz-link.htm

This was originally copied from the sandbox of the CPython CVS repository.

Thanks to Tim Peters for suggesting using it.

"""

import time as _time

import math as _math

def _cmp(x, y):

return 0 if x == y else 1 if x > y else -1

MINYEAR = 1

MAXYEAR = 9999

_MAXORDINAL = 3652059 # date.max.toordinal()

# Utility functions, adapted from Python's Demo/classes/Dates.py, which

# also assumes the current Gregorian calendar indefinitely extended in

# both directions. Difference: Dates.py calls January 1 of year 0 day

# number 1. The code here calls January 1 of year 1 day number 1. This is

# to match the definition of the "proleptic Gregorian" calendar in Dershowitz

# and Reingold's "Calendrical Calculations", where it's the base calendar

# for all computations. See the book for algorithms for converting between

# proleptic Gregorian ordinals and many other calendar systems.

_DAYS_IN_MONTH = [None, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]

_DAYS_BEFORE_MONTH = [None]

dbm = 0

for dim in _DAYS_IN_MONTH[1:]:

_DAYS_BEFORE_MONTH.append(dbm)

dbm += dim

del dbm, dim

def _is_leap(year):

"year -> 1 if leap year, else 0."

return year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)

def _days_before_year(year):

"year -> number of days before January 1st of year."

y = year - 1

return y*365 + y//4 - y//100 + y//400

def _days_in_month(year, month):

"year, month -> number of days in that month in that year."

assert 1 <= month <= 12, month

if month == 2 and _is_leap(year):

return 29

return _DAYS_IN_MONTH[month]

def _days_before_month(year, month):

"year, month -> number of days in year preceeding first day of month."

assert 1 <= month <= 12, 'month must be in 1..12'

return _DAYS_BEFORE_MONTH[month] + (month > 2 and _is_leap(year))

def _ymd2ord(year, month, day):

"year, month, day -> ordinal, considering 01-Jan-0001 as day 1."

assert 1 <= month <= 12, 'month must be in 1..12'

dim = _days_in_month(year, month)

assert 1 <= day <= dim, ('day must be in 1..%d' % dim)

return (_days_before_year(year) +

_days_before_month(year, month) +

day)

_DI400Y = _days_before_year(401) # number of days in 400 years

_DI100Y = _days_before_year(101) # " " " " 100 "

_DI4Y = _days_before_year(5) # " " " " 4 "

# A 4-year cycle has an extra leap day over what we'd get from pasting

# together 4 single years.

assert _DI4Y == 4 * 365 + 1

# Similarly, a 400-year cycle has an extra leap day over what we'd get from

# pasting together 4 100-year cycles.

assert _DI400Y == 4 * _DI100Y + 1

# OTOH, a 100-year cycle has one fewer leap day than we'd get from

# pasting together 25 4-year cycles.

assert _DI100Y == 25 * _DI4Y - 1

def _ord2ymd(n):

"ordinal -> (year, month, day), considering 01-Jan-0001 as day 1."

# n is a 1-based index, starting at 1-Jan-1. The pattern of leap years

# repeats exactly every 400 years. The basic strategy is to find the

# closest 400-year boundary at or before n, then work with the offset

# from that boundary to n. Life is much clearer if we subtract 1 from

# n first -- then the values of n at 400-year boundaries are exactly

# those divisible by _DI400Y:

#

# D M Y n n-1

# -- --- ---- ---------- ----------------

# 31 Dec -400 -_DI400Y -_DI400Y -1

# 1 Jan -399 -_DI400Y +1 -_DI400Y 400-year boundary

# ...

# 30 Dec 000 -1 -2

# 31 Dec 000 0 -1

# 1 Jan 001 1 0 400-year boundary

# 2 Jan 001 2 1

# 3 Jan 001 3 2

# ...

# 31 Dec 400 _DI400Y _DI400Y -1

# 1 Jan 401 _DI400Y +1 _DI400Y 400-year boundary

n -= 1

n400, n = divmod(n, _DI400Y)

year = n400 * 400 + 1 # ..., -399, 1, 401, ...

# Now n is the (non-negative) offset, in days, from January 1 of year, to

# the desired date. Now compute how many 100-year cycles precede n.

# Note that it's possible for n100 to equal 4! In that case 4 full

# 100-year cycles precede the desired day, which implies the desired

# day is December 31 at the end of a 400-year cycle.

n100, n = divmod(n, _DI100Y)

# Now compute how many 4-year cycles precede it.

n4, n = divmod(n, _DI4Y)

# And now how many single years. Again n1 can be 4, and again meaning

# that the desired day is December 31 at the end of the 4-year cycle.

n1, n = divmod(n, 365)

year += n100 * 100 + n4 * 4 + n1

if n1 == 4 or n100 == 4:

assert n == 0

return year-1, 12, 31

# Now the year is correct, and n is the offset from January 1. We find

# the month via an estimate that's either exact or one too large.

leapyear = n1 == 3 and (n4 != 24 or n100 == 3)

assert leapyear == _is_leap(year)

month = (n + 50) >> 5

preceding = _DAYS_BEFORE_MONTH[month] + (month > 2 and leapyear)

if preceding > n: # estimate is too large

month -= 1

preceding -= _DAYS_IN_MONTH[month] + (month == 2 and leapyear)

n -= preceding

assert 0 <= n < _days_in_month(year, month)

# Now the year and month are correct, and n is the offset from the

# start of that month: we're done!

return year, month, n+1

# Month and day names. For localized versions, see the calendar module.

_MONTHNAMES = [None, "Jan", "Feb", "Mar", "Apr", "May", "Jun",

"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]

_DAYNAMES = [None, "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]

def _build_struct_time(y, m, d, hh, mm, ss, dstflag):

wday = (_ymd2ord(y, m, d) + 6) % 7

dnum = _days_before_month(y, m) + d

return _time.struct_time((y, m, d, hh, mm, ss, wday, dnum, dstflag))

def _format_time(hh, mm, ss, us):

# Skip trailing microseconds when us==0.

result = "%02d:%02d:%02d" % (hh, mm, ss)

if us:

result += ".%06d" % us

return result

# Correctly substitute for %z and %Z escapes in strftime formats.

def _wrap_strftime(object, format, timetuple):

year = timetuple[0]

if year < 1900:

raise ValueError("year=%d is before 1900; the datetime strftime() "

"methods require year >= 1900" % year)

# Don't call utcoffset() or tzname() unless actually needed.

freplace = None # the string to use for %f

zreplace = None # the string to use for %z

Zreplace = None # the string to use for %Z

# Scan format for %z and %Z escapes, replacing as needed.

newformat = []

push = newformat.append

i, n = 0, len(format)

while i < n:

ch = format[i]

i += 1

if ch == '%':

if i < n:

ch = format[i]

i += 1

if ch == 'f':

if freplace is None:

freplace = '%06d' % getattr(object,

'microsecond', 0)

newformat.append(freplace)

elif ch == 'z':

if zreplace is None:

zreplace = ""

if hasattr(object, "utcoffset"):

offset = object.utcoffset()

if offset is not None:

sign = '+'

if offset.days < 0:

offset = -offset

sign = '-'

h, m = divmod(offset, timedelta(hours=1))

assert not m % timedelta(minutes=1), "whole minute"

m //= timedelta(minutes=1)

zreplace = '%c%02d%02d' % (sign, h, m)

assert '%' not in zreplace

newformat.append(zreplace)

elif ch == 'Z':

if Zreplace is None:

Zreplace = ""

if hasattr(object, "tzname"):

s = object.tzname()

if s is not None:

# strftime is going to have at this: escape %

Zreplace = s.replace('%', '%%')

newformat.append(Zreplace)

else:

push('%')

push(ch)

else:

push('%')

else:

push(ch)

newformat = "".join(newformat)

return _time.strftime(newformat, timetuple)

def _call_tzinfo_method(tzinfo, methname, tzinfoarg):

if tzinfo is None:

return None

return getattr(tzinfo, methname)(tzinfoarg)

# Just raise TypeError if the arg isn't None or a string.

def _check_tzname(name):

if name is not None and not isinstance(name, str):

raise TypeError("tzinfo.tzname() must return None or string, "

"not '%s'" % type(name))

# name is the offset-producing method, "utcoffset" or "dst".

# offset is what it returned.

# If offset isn't None or timedelta, raises TypeError.

# If offset is None, returns None.

# Else offset is checked for being in range, and a whole # of minutes.

# If it is, its integer value is returned. Else ValueError is raised.

def _check_utc_offset(name, offset):

assert name in ("utcoffset", "dst")

if offset is None:

return

if not isinstance(offset, timedelta):

raise TypeError("tzinfo.%s() must return None "

"or timedelta, not '%s'" % (name, type(offset)))

if offset % timedelta(minutes=1) or offset.microseconds:

raise ValueError("tzinfo.%s() must return a whole number "

"of minutes, got %s" % (name, offset))

if not -timedelta(1) < offset < timedelta(1):

raise ValueError("%s()=%s, must be must be strictly between"

" -timedelta(hours=24) and timedelta(hours=24)"

% (name, offset))

def _check_date_fields(year, month, day):

if not isinstance(year, int):

raise TypeError('int expected')

if not MINYEAR <= year <= MAXYEAR:

raise ValueError('year must be in %d..%d' % (MINYEAR, MAXYEAR), year)

if not 1 <= month <= 12:

raise ValueError('month must be in 1..12', month)

dim = _days_in_month(year, month)

if not 1 <= day <= dim:

raise ValueError('day must be in 1..%d' % dim, day)

def _check_time_fields(hour, minute, second, microsecond):

if not isinstance(hour, int):

raise TypeError('int expected')

if not 0 <= hour <= 23:

raise ValueError('hour must be in 0..23', hour)

if not 0 <= minute <= 59:

raise ValueError('minute must be in 0..59', minute)

if not 0 <= second <= 59:

raise ValueError('second must be in 0..59', second)

if not 0 <= microsecond <= 999999:

raise ValueError('microsecond must be in 0..999999', microsecond)

def _check_tzinfo_arg(tz):

if tz is not None and not isinstance(tz, tzinfo):

raise TypeError("tzinfo argument must be None or of a tzinfo subclass")

def _cmperror(x, y):

raise TypeError("can't compare '%s' to '%s'" % (

type(x).__name__, type(y).__name__))

class timedelta:

"""Represent the difference between two datetime objects.

Supported operators:

- add, subtract timedelta

- unary plus, minus, abs

- compare to timedelta

- multiply, divide by int/long

In addition, datetime supports subtraction of two datetime objects

returning a timedelta, and addition or subtraction of a datetime

and a timedelta giving a datetime.

Representation: (days, seconds, microseconds). Why? Because I

felt like it.

"""

__slots__ = '_days', '_seconds', '_microseconds'

def __new__(cls, days=0, seconds=0, microseconds=0,

milliseconds=0, minutes=0, hours=0, weeks=0):

# Doing this efficiently and accurately in C is going to be difficult

# and error-prone, due to ubiquitous overflow possibilities, and that

# C double doesn't have enough bits of precision to represent

# microseconds over 10K years faithfully. The code here tries to make

# explicit where go-fast assumptions can be relied on, in order to

# guide the C implementation; it's way more convoluted than speed-

# ignoring auto-overflow-to-long idiomatic Python could be.

# XXX Check that all inputs are ints or floats.

# Final values, all integer.

# s and us fit in 32-bit signed ints; d isn't bounded.

d = s = us = 0

# Normalize everything to days, seconds, microseconds.

days += weeks*7

seconds += minutes*60 + hours*3600

microseconds += milliseconds*1000

# Get rid of all fractions, and normalize s and us.

# Take a deep breath <wink>.

if isinstance(days, float):

dayfrac, days = _math.modf(days)

daysecondsfrac, daysecondswhole = _math.modf(dayfrac * (24.*3600.))

assert daysecondswhole == int(daysecondswhole) # can't overflow

s = int(daysecondswhole)

assert days == int(days)

d = int(days)

else:

daysecondsfrac = 0.0

d = days

assert isinstance(daysecondsfrac, float)

assert abs(daysecondsfrac) <= 1.0

assert isinstance(d, int)

assert abs(s) <= 24 * 3600

# days isn't referenced again before redefinition

if isinstance(seconds, float):

secondsfrac, seconds = _math.modf(seconds)

assert seconds == int(seconds)

seconds = int(seconds)

secondsfrac += daysecondsfrac

assert abs(secondsfrac) <= 2.0

else:

secondsfrac = daysecondsfrac

# daysecondsfrac isn't referenced again

assert isinstance(secondsfrac, float)

assert abs(secondsfrac) <= 2.0

assert isinstance(seconds, int)

days, seconds = divmod(seconds, 24*3600)

d += days

s += int(seconds) # can't overflow

assert isinstance(s, int)

assert abs(s) <= 2 * 24 * 3600

# seconds isn't referenced again before redefinition

usdouble = secondsfrac * 1e6

assert abs(usdouble) < 2.1e6 # exact value not critical

# secondsfrac isn't referenced again

if isinstance(microseconds, float):

microseconds += usdouble

microseconds = round(microseconds, 0)

seconds, microseconds = divmod(microseconds, 1e6)

assert microseconds == int(microseconds)

assert seconds == int(seconds)

days, seconds = divmod(seconds, 24.*3600.)

assert days == int(days)

assert seconds == int(seconds)

d += int(days)

s += int(seconds) # can't overflow

assert isinstance(s, int)

assert abs(s) <= 3 * 24 * 3600

else:

seconds, microseconds = divmod(microseconds, 1000000)

days, seconds = divmod(seconds, 24*3600)

d += days

s += int(seconds) # can't overflow

assert isinstance(s, int)

assert abs(s) <= 3 * 24 * 3600

microseconds = float(microseconds)

microseconds += usdouble

microseconds = round(microseconds, 0)

assert abs(s) <= 3 * 24 * 3600

assert abs(microseconds) < 3.1e6

# Just a little bit of carrying possible for microseconds and seconds.

assert isinstance(microseconds, float)

assert int(microseconds) == microseconds

us = int(microseconds)

seconds, us = divmod(us, 1000000)

s += seconds # cant't overflow

assert isinstance(s, int)

days, s = divmod(s, 24*3600)

d += days

assert isinstance(d, int)

assert isinstance(s, int) and 0 <= s < 24*3600

assert isinstance(us, int) and 0 <= us < 1000000

self = object.__new__(cls)

self._days = d

self._seconds = s

self._microseconds = us

if abs(d) > 999999999:

raise OverflowError("timedelta # of days is too large: %d" % d)

return self

def __repr__(self):

if self._microseconds:

return "%s(%d, %d, %d)" % ('datetime.' + self.__class__.__name__,

self._days,

self._seconds,

self._microseconds)

if self._seconds:

return "%s(%d, %d)" % ('datetime.' + self.__class__.__name__,

self._days,

self._seconds)

return "%s(%d)" % ('datetime.' + self.__class__.__name__, self._days)

def __str__(self):

mm, ss = divmod(self._seconds, 60)

hh, mm = divmod(mm, 60)

s = "%d:%02d:%02d" % (hh, mm, ss)

if self._days:

def plural(n):

return n, abs(n) != 1 and "s" or ""

s = ("%d day%s, " % plural(self._days)) + s

if self._microseconds:

s = s + ".%06d" % self._microseconds

return s

def total_seconds(self):

"""Total seconds in the duration."""

return ((self.days * 86400 + self.seconds)*10**6 +

self.microseconds) / 10**6

# Read-only field accessors

@property

def days(self):

"""days"""

return self._days

@property

def seconds(self):

"""seconds"""

return self._seconds

@property

def microseconds(self):

"""microseconds"""

return self._microseconds

def __add__(self, other):

if isinstance(other, timedelta):

# for CPython compatibility, we cannot use

# our __class__ here, but need a real timedelta

return timedelta(self._days + other._days,

self._seconds + other._seconds,

self._microseconds + other._microseconds)

return NotImplemented

__radd__ = __add__

def __sub__(self, other):

if isinstance(other, timedelta):

return self + -other

return NotImplemented

def __rsub__(self, other):

if isinstance(other, timedelta):

return -self + other

return NotImplemented

def __neg__(self):

# for CPython compatibility, we cannot use

# our __class__ here, but need a real timedelta

return timedelta(-self._days,

-self._seconds,

-self._microseconds)

def __pos__(self):

return self

def __abs__(self):

if self._days < 0:

return -self

else:

return self

def __mul__(self, other):

if isinstance(other, int):

# for CPython compatibility, we cannot use

# our __class__ here, but need a real timedelta

return timedelta(self._days * other,

self._seconds * other,

self._microseconds * other)

if isinstance(other, float):

a, b = other.as_integer_ratio()

return self * a / b

return NotImplemented

__rmul__ = __mul__

def _to_microseconds(self):

return ((self._days * (24*3600) + self._seconds) * 1000000 +

self._microseconds)

def __floordiv__(self, other):

if not isinstance(other, (int, timedelta)):

return NotImplemented

usec = self._to_microseconds()

if isinstance(other, timedelta):

return usec // other._to_microseconds()

if isinstance(other, int):

return timedelta(0, 0, usec // other)

def __truediv__(self, other):

if not isinstance(other, (int, float, timedelta)):

return NotImplemented

usec = self._to_microseconds()

if isinstance(other, timedelta):

return usec / other._to_microseconds()

if isinstance(other, int):

return timedelta(0, 0, usec / other)

if isinstance(other, float):

a, b = other.as_integer_ratio()

return timedelta(0, 0, b * usec / a)

def __mod__(self, other):

if isinstance(other, timedelta):

r = self._to_microseconds() % other._to_microseconds()

return timedelta(0, 0, r)

return NotImplemented

def __divmod__(self, other):

if isinstance(other, timedelta):

q, r = divmod(self._to_microseconds(),

other._to_microseconds())

return q, timedelta(0, 0, r)

return NotImplemented

# Comparisons of timedelta objects with other.

def __eq__(self, other):

if isinstance(other, timedelta):

return self._cmp(other) == 0

else:

return False

def __ne__(self, other):

if isinstance(other, timedelta):

return self._cmp(other) != 0

else:

return True

def __le__(self, other):

if isinstance(other, timedelta):

return self._cmp(other) <= 0

else:

_cmperror(self, other)

def __lt__(self, other):

if isinstance(other, timedelta):

return self._cmp(other) < 0

else:

_cmperror(self, other)

def __ge__(self, other):

if isinstance(other, timedelta):

return self._cmp(other) >= 0

else:

_cmperror(self, other)

def __gt__(self, other):

if isinstance(other, timedelta):

return self._cmp(other) > 0

else:

_cmperror(self, other)

def _cmp(self, other):

assert isinstance(other, timedelta)

return _cmp(self._getstate(), other._getstate())

def __hash__(self):

return hash(self._getstate())

def __bool__(self):

return (self._days != 0 or

self._seconds != 0 or

self._microseconds != 0)

# Pickle support.

def _getstate(self):

return (self._days, self._seconds, self._microseconds)

def __reduce__(self):

return (self.__class__, self._getstate())

timedelta.min = timedelta(-999999999)

timedelta.max = timedelta(days=999999999, hours=23, minutes=59, seconds=59,

microseconds=999999)

timedelta.resolution = timedelta(microseconds=1)

class date:

"""Concrete date type.

Constructors:

__new__()

fromtimestamp()

today()

fromordinal()

Operators:

__repr__, __str__

__cmp__, __hash__

__add__, __radd__, __sub__ (add/radd only with timedelta arg)

Methods:

timetuple()

toordinal()

weekday()

isoweekday(), isocalendar(), isoformat()

ctime()

strftime()

Properties (readonly):

year, month, day

"""

__slots__ = '_year', '_month', '_day'

def __new__(cls, year, month=None, day=None):

"""Constructor.

Arguments:

year, month, day (required, base 1)

"""

if (isinstance(year, bytes) and len(year) == 4 and

1 <= year[2] <= 12 and month is None): # Month is sane

# Pickle support

self = object.__new__(cls)

self.__setstate(year)

return self

_check_date_fields(year, month, day)

self = object.__new__(cls)

self._year = year

self._month = month

self._day = day

return self

# Additional constructors

@classmethod

def fromtimestamp(cls, t):

"Construct a date from a POSIX timestamp (like time.time())."

y, m, d, hh, mm, ss, weekday, jday, dst = _time.localtime(t)

return cls(y, m, d)

@classmethod

def today(cls):

"Construct a date from time.time()."

t = _time.time()

return cls.fromtimestamp(t)

@classmethod

def fromordinal(cls, n):

"""Contruct a date from a proleptic Gregorian ordinal.

January 1 of year 1 is day 1. Only the year, month and day are

non-zero in the result.

"""

y, m, d = _ord2ymd(n)

return cls(y, m, d)

# Conversions to string

def __repr__(self):

"""Convert to formal string, for repr().

>>> dt = datetime(2010, 1, 1)

>>> repr(dt)

'datetime.datetime(2010, 1, 1, 0, 0)'

>>> dt = datetime(2010, 1, 1, tzinfo=timezone.utc)

>>> repr(dt)

'datetime.datetime(2010, 1, 1, 0, 0, tzinfo=datetime.timezone.utc)'

"""

return "%s(%d, %d, %d)" % ('datetime.' + self.__class__.__name__,

self._year,

self._month,

self._day)

# XXX These shouldn't depend on time.localtime(), because that

# clips the usable dates to [1970 .. 2038). At least ctime() is

# easily done without using strftime() -- that's better too because

# strftime("%c", ...) is locale specific.

def ctime(self):

"Return ctime() style string."

weekday = self.toordinal() % 7 or 7

return "%s %s %2d 00:00:00 %04d" % (

_DAYNAMES[weekday],

_MONTHNAMES[self._month],

self._day, self._year)

def strftime(self, fmt):

"Format using strftime()."

return _wrap_strftime(self, fmt, self.timetuple())

def __format__(self, fmt):

if len(fmt) != 0:

return self.strftime(fmt)

return str(self)

def isoformat(self):

"""Return the date formatted according to ISO.

This is 'YYYY-MM-DD'.

References:

- http://www.w3.org/TR/NOTE-datetime

- http://www.cl.cam.ac.uk/~mgk25/iso-time.html

"""

return "%04d-%02d-%02d" % (self._year, self._month, self._day)

__str__ = isoformat

# Read-only field accessors

@property

def year(self):

"""year (1-9999)"""

return self._year

@property

def month(self):

"""month (1-12)"""

return self._month

@property

def day(self):

"""day (1-31)"""

return self._day

# Standard conversions, __cmp__, __hash__ (and helpers)

def timetuple(self):

"Return local time tuple compatible with time.localtime()."

return _build_struct_time(self._year, self._month, self._day,

0, 0, 0, -1)

def toordinal(self):

"""Return proleptic Gregorian ordinal for the year, month and day.

January 1 of year 1 is day 1. Only the year, month and day values

contribute to the result.

"""

return _ymd2ord(self._year, self._month, self._day)

def replace(self, year=None, month=None, day=None):

"""Return a new date with new values for the specified fields."""

if year is None:

year = self._year

if month is None:

month = self._month

if day is None:

day = self._day

_check_date_fields(year, month, day)

return date(year, month, day)

# Comparisons of date objects with other.

def __eq__(self, other):

if isinstance(other, date):

return self._cmp(other) == 0

return NotImplemented

def __ne__(self, other):

if isinstance(other, date):

return self._cmp(other) != 0

return NotImplemented

def __le__(self, other):

if isinstance(other, date):

return self._cmp(other) <= 0

return NotImplemented

def __lt__(self, other):

if isinstance(other, date):

return self._cmp(other) < 0

return NotImplemented

def __ge__(self, other):

if isinstance(other, date):

return self._cmp(other) >= 0

return NotImplemented

def __gt__(self, other):

if isinstance(other, date):

return self._cmp(other) > 0

return NotImplemented

def _cmp(self, other):

assert isinstance(other, date)

y, m, d = self._year, self._month, self._day

y2, m2, d2 = other._year, other._month, other._day

return _cmp((y, m, d), (y2, m2, d2))

def __hash__(self):

"Hash."

return hash(self._getstate())

# Computations

def __add__(self, other):

"Add a date to a timedelta."

if isinstance(other, timedelta):

o = self.toordinal() + other.days

if 0 < o <= _MAXORDINAL:

return date.fromordinal(o)

raise OverflowError("result out of range")

return NotImplemented

__radd__ = __add__

def __sub__(self, other):

"""Subtract two dates, or a date and a timedelta."""

if isinstance(other, timedelta):

return self + timedelta(-other.days)

if isinstance(other, date):

days1 = self.toordinal()

days2 = other.toordinal()

return timedelta(days1 - days2)

return NotImplemented

def weekday(self):

"Return day of the week, where Monday == 0 ... Sunday == 6."

return (self.toordinal() + 6) % 7

# Day-of-the-week and week-of-the-year, according to ISO

def isoweekday(self):

"Return day of the week, where Monday == 1 ... Sunday == 7."

# 1-Jan-0001 is a Monday

return self.toordinal() % 7 or 7

def isocalendar(self):

"""Return a 3-tuple containing ISO year, week number, and weekday.

The first ISO week of the year is the (Mon-Sun) week

containing the year's first Thursday; everything else derives

from that.

The first week is 1; Monday is 1 ... Sunday is 7.

ISO calendar algorithm taken from

http://www.phys.uu.nl/~vgent/calendar/isocalendar.htm

"""

year = self._year

week1monday = _isoweek1monday(year)

today = _ymd2ord(self._year, self._month, self._day)

# Internally, week and day have origin 0

week, day = divmod(today - week1monday, 7)

if week < 0:

year -= 1

week1monday = _isoweek1monday(year)

week, day = divmod(today - week1monday, 7)

elif week >= 52:

if today >= _isoweek1monday(year+1):

year += 1

week = 0

return year, week+1, day+1

# Pickle support.

def _getstate(self):

yhi, ylo = divmod(self._year, 256)

return bytes([yhi, ylo, self._month, self._day]),

def __setstate(self, string):

if len(string) != 4 or not (1 <= string[2] <= 12):

raise TypeError("not enough arguments")

yhi, ylo, self._month, self._day = string

self._year = yhi * 256 + ylo

def __reduce__(self):

return (self.__class__, self._getstate())

_date_class = date # so functions w/ args named "date" can get at the class

date.min = date(1, 1, 1)

date.max = date(9999, 12, 31)

date.resolution = timedelta(days=1)

class tzinfo:

"""Abstract base class for time zone info classes.

Subclasses must override the name(), utcoffset() and dst() methods.

"""

__slots__ = ()

def tzname(self, dt):

"datetime -> string name of time zone."

raise NotImplementedError("tzinfo subclass must override tzname()")

def utcoffset(self, dt):

"datetime -> minutes east of UTC (negative for west of UTC)"

raise NotImplementedError("tzinfo subclass must override utcoffset()")

def dst(self, dt):

"""datetime -> DST offset in minutes east of UTC.

Return 0 if DST not in effect. utcoffset() must include the DST

offset.

"""

raise NotImplementedError("tzinfo subclass must override dst()")

def fromutc(self, dt):

"datetime in UTC -> datetime in local time."

if not isinstance(dt, datetime):

raise TypeError("fromutc() requires a datetime argument")

if dt.tzinfo is not self:

raise ValueError("dt.tzinfo is not self")

dtoff = dt.utcoffset()

if dtoff is None:

raise ValueError("fromutc() requires a non-None utcoffset() "

"result")

# See the long comment block at the end of this file for an

# explanation of this algorithm.

dtdst = dt.dst()

if dtdst is None:

raise ValueError("fromutc() requires a non-None dst() result")

delta = dtoff - dtdst

if delta:

dt += delta

dtdst = dt.dst()

if dtdst is None:

raise ValueError("fromutc(): dt.dst gave inconsistent "

"results; cannot convert")

return dt + dtdst

# Pickle support.

def __reduce__(self):

getinitargs = getattr(self, "__getinitargs__", None)

if getinitargs:

args = getinitargs()

else:

args = ()

getstate = getattr(self, "__getstate__", None)

if getstate:

state = getstate()

else:

state = getattr(self, "__dict__", None) or None

if state is None:

return (self.__class__, args)

else:

return (self.__class__, args, state)

_tzinfo_class = tzinfo

class time:

"""Time with time zone.

Constructors:

__new__()

Operators:

__repr__, __str__

__cmp__, __hash__