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

specs = {

'hours': '{:02d}',

'minutes': '{:02d}:{:02d}',

'seconds': '{:02d}:{:02d}:{:02d}',

'milliseconds': '{:02d}:{:02d}:{:02d}.{:03d}',

'microseconds': '{:02d}:{:02d}:{:02d}.{:06d}'

}

if timespec == 'auto':

# Skip trailing microseconds when us==0.

timespec = 'microseconds' if us else 'seconds'

elif timespec == 'milliseconds':

us //= 1000

try:

fmt = specs[timespec]

except KeyError:

raise ValueError('Unknown timespec value')

else:

s = ''

if off is not None:

if off.days < 0:

sign = "-"

off = -off

else:

sign = "+"

hh, mm = divmod(off, timedelta(hours=1))

mm, ss = divmod(mm, timedelta(minutes=1))

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

if ss or ss.microseconds:

s += ":%02d" % ss.seconds

if ss.microseconds:

s += '.%06d' % ss.microseconds

# 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, rest = divmod(offset, timedelta(hours=1))

m, rest = divmod(rest, timedelta(minutes=1))

s = rest.seconds

u = offset.microseconds

if u:

zreplace = '%c%02d%02d%02d.%06d' % (sign, h, m, s, u)

elif s:

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

else:

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)

# It is assumed that this function will only be called with a

# string of length exactly 10, and (though this is not used) ASCII-only

year = int(dtstr[0:4])

if dtstr[4] != '-':

raise ValueError('Invalid date separator: %s' % dtstr[4])

month = int(dtstr[5:7])

if dtstr[7] != '-':

raise ValueError('Invalid date separator')

day = int(dtstr[8:10])

# Parses things of the form HH[:MM[:SS[.fff[fff]]]]

len_str = len(tstr)

time_comps = [0, 0, 0, 0]

pos = 0

for comp in range(0, 3):

if (len_str - pos) < 2:

raise ValueError('Incomplete time component')

time_comps[comp] = int(tstr[pos:pos+2])

pos += 2

next_char = tstr[pos:pos+1]

if not next_char or comp >= 2:

break

if next_char != ':':

raise ValueError('Invalid time separator: %c' % next_char)

pos += 1

if pos < len_str:

if tstr[pos] != '.':

raise ValueError('Invalid microsecond component')

else:

pos += 1

len_remainder = len_str - pos

if len_remainder not in (3, 6):

raise ValueError('Invalid microsecond component')

time_comps[3] = int(tstr[pos:])

if len_remainder == 3:

time_comps[3] *= 1000

# Format supported is HH[:MM[:SS[.fff[fff]]]][+HH:MM[:SS[.ffffff]]]

len_str = len(tstr)

if len_str < 2:

raise ValueError('Isoformat time too short')

# This is equivalent to re.search('[+-]', tstr), but faster

tz_pos = (tstr.find('-') + 1 or tstr.find('+') + 1)

timestr = tstr[:tz_pos-1] if tz_pos > 0 else tstr

time_comps = _parse_hh_mm_ss_ff(timestr)

tzi = None

if tz_pos > 0:

tzstr = tstr[tz_pos:]

# Valid time zone strings are:

# HH:MM len: 5

# HH:MM:SS len: 8

# HH:MM:SS.ffffff len: 15

if len(tzstr) not in (5, 8, 15):

raise ValueError('Malformed time zone string')

tz_comps = _parse_hh_mm_ss_ff(tzstr)

if all(x == 0 for x in tz_comps):

tzi = timezone.utc

else:

tzsign = -1 if tstr[tz_pos - 1] == '-' else 1

td = timedelta(hours=tz_comps[0], minutes=tz_comps[1],

seconds=tz_comps[2], microseconds=tz_comps[3])

tzi = timezone(tzsign * td)

time_comps.append(tzi)

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 not -timedelta(1) < offset < timedelta(1):

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

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

if isinstance(value, int):

return value

if isinstance(value, float):

raise TypeError('integer argument expected, got float')

try:

value = value.__index__()

except AttributeError:

pass

else:

if not isinstance(value, int):

raise TypeError('__index__ returned non-int (type %s)' %

type(value).__name__)

return value

orig = value

try:

value = value.__int__()

except AttributeError:

pass

else:

if not isinstance(value, int):

raise TypeError('__int__ returned non-int (type %s)' %

type(value).__name__)

import warnings

warnings.warn("an integer is required (got type %s)" %

type(orig).__name__,

DeprecationWarning,

stacklevel=2)

return value

raise TypeError('an integer is required (got type %s)' %

year = _check_int_field(year)

month = _check_int_field(month)

day = _check_int_field(day)

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)

hour = _check_int_field(hour)

minute = _check_int_field(minute)

second = _check_int_field(second)

microsecond = _check_int_field(microsecond)

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)

if fold not in (0, 1):

raise ValueError('fold must be either 0 or 1', fold)

"""divide a by b and round result to the nearest integer

# Based on the reference implementation for divmod_near

# in Objects/longobject.c.

q, r = divmod(a, b)

# round up if either r / b > 0.5, or r / b == 0.5 and q is odd.

# The expression r / b > 0.5 is equivalent to 2 * r > b if b is

# positive, 2 * r < b if b negative.

r *= 2

greater_than_half = r > b if b > 0 else r < b

if greater_than_half or r == b and q % 2 == 1:

q += 1

"""Represent the difference between two datetime objects.

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

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 = round(microseconds + usdouble)

seconds, microseconds = divmod(microseconds, 1000000)

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

d += days

s += seconds

else:

microseconds = int(microseconds)

seconds, microseconds = divmod(microseconds, 1000000)

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

d += days

s += seconds

microseconds = round(microseconds + usdouble)

assert isinstance(s, int)

assert isinstance(microseconds, int)

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

assert abs(microseconds) < 3.1e6

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

seconds, us = divmod(microseconds, 1000000)

s += seconds

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

if abs(d) > 999999999:

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

self = object.__new__(cls)

self._days = d

self._seconds = s

self._microseconds = us

self._hashcode = -1

return self

def __repr__(self):

args = []

if self._days:

args.append("days=%d" % self._days)

if self._seconds:

args.append("seconds=%d" % self._seconds)

if self._microseconds:

args.append("microseconds=%d" % self._microseconds)

if not args:

args.append('0')

return "%s.%s(%s)" % (self.__class__.__module__,

self.__class__.__qualname__,

', '.join(args))

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

usec = self._to_microseconds()

a, b = other.as_integer_ratio()

return timedelta(0, 0, _divide_and_round(usec * 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, _divide_and_round(usec, other))

if isinstance(other, float):

a, b = other.as_integer_ratio()

return timedelta(0, 0, _divide_and_round(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 NotImplemented

def __le__(self, other):

if isinstance(other, timedelta):

return self._cmp(other) <= 0

else:

return NotImplemented

def __lt__(self, other):

if isinstance(other, timedelta):

return self._cmp(other) < 0

else:

return NotImplemented

def __ge__(self, other):

if isinstance(other, timedelta):

return self._cmp(other) >= 0

else:

return NotImplemented

def __gt__(self, other):

if isinstance(other, timedelta):

return self._cmp(other) > 0

else:

return NotImplemented

def _cmp(self, other):

assert isinstance(other, timedelta)

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

def __hash__(self):

if self._hashcode == -1:

self._hashcode = hash(self._getstate())

return self._hashcode

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', '_hashcode'

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

"""Constructor.

if (month is None and

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

1 <= ord(year[2:3]) <= 12):

# Pickle support

if isinstance(year, str):

try:

year = year.encode('latin1')

except UnicodeEncodeError:

# More informative error message.

raise ValueError(

"Failed to encode latin1 string when unpickling "

"a date object. "

"pickle.load(data, encoding='latin1') is assumed.")

self = object.__new__(cls)

self.__setstate(year)

self._hashcode = -1

return self

year, month, day = _check_date_fields(year, month, day)

self = object.__new__(cls)

self._year = year

self._month = month

self._day = day

self._hashcode = -1

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

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

y, m, d = _ord2ymd(n)

return cls(y, m, d)

@classmethod

def fromisoformat(cls, date_string):

"""Construct a date from the output of date.isoformat()."""

if not isinstance(date_string, str):

raise TypeError('fromisoformat: argument must be str')

try:

assert len(date_string) == 10

return cls(*_parse_isoformat_date(date_string))

except Exception:

raise ValueError(f'Invalid isoformat string: {date_string!r}')

@classmethod

def fromisocalendar(cls, year, week, day):

"""Construct a date from the ISO year, week number and weekday.

# Year is bounded this way because 9999-12-31 is (9999, 52, 5)

if not MINYEAR <= year <= MAXYEAR:

raise ValueError(f"Year is out of range: {year}")

if not 0 < week < 53:

out_of_range = True

if week == 53:

# ISO years have 53 weeks in them on years starting with a

# Thursday and leap years starting on a Wednesday

first_weekday = _ymd2ord(year, 1, 1) % 7

if (first_weekday == 4 or (first_weekday == 3 and

_is_leap(year))):

out_of_range = False

if out_of_range:

raise ValueError(f"Invalid week: {week}")

if not 0 < day < 8:

raise ValueError(f"Invalid weekday: {day} (range is [1, 7])")

# Now compute the offset from (Y, 1, 1) in days:

day_offset = (week - 1) * 7 + (day - 1)

# Calculate the ordinal day for monday, week 1

day_1 = _isoweek1monday(year)

ord_day = day_1 + day_offset

return cls(*_ord2ymd(ord_day))

# Conversions to string

def __repr__(self):

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

return "%s.%s(%d, %d, %d)" % (self.__class__.__module__,

self.__class__.__qualname__,

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 not isinstance(fmt, str):

raise TypeError("must be str, not %s" % type(fmt).__name__)

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, __eq__, __le__, __lt__, __ge__, __gt__,

# __hash__ (and helpers)