"""Concrete date/time and related types.

See http://www.iana.org/time-zones/repository/tz-link.html for

time zone and DST data sources.

"""

import time as _time

import math as _math

import sys

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.

# -1 is a placeholder for indexing purposes.

_DAYS_IN_MONTH = [-1, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]

_DAYS_BEFORE_MONTH = [-1] # -1 is a placeholder for indexing purposes.

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 preceding 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, timespec='auto'):

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:

return fmt.format(hh, mm, ss, us)

def _format_offset(off):

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

return s

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

def _wrap_strftime(object, format, timetuple):

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

return _time.strftime(newformat, timetuple)

# Helpers for parsing the result of isoformat()

def _parse_isoformat_date(dtstr):

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

return [year, month, day]

def _parse_hh_mm_ss_ff(tstr):

# 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

return time_comps

def _parse_isoformat_time(tstr):

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

return time_comps

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

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

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

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

(name, offset))

def _check_int_field(value):

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)' %

type(value).__name__)

def _check_date_fields(year, month, day):

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)

return year, month, day

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

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)

return hour, minute, second, microsecond, fold

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

def _divide_and_round(a, b):

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

When the ratio is exactly half-way between two integers,

the even integer is returned.

"""

# 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

return q

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

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', '_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 False

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

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

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__

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

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

"""Constructor.

Arguments:

year, month, day (required, base 1)

"""

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.

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)

@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}')

# 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.%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.

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

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

return type(self)(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 __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