"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

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

"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!

# Skip trailing microseconds when us==0.

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

if us:

result += ".%06d" % us

# 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)

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

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:

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:

"""Represent the difference between two datetime objects.

__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):

# 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

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):

"""Concrete date type.

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

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

"""Constructor.

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.

y, m, d = _ord2ymd(n)

return cls(y, m, d)

# Conversions to string

def __repr__(self):

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

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.

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.

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.

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):

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

__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.

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:

"""Time with time zone.