"""Pure Python implementation of the datetime module."""

__all__ = ("date", "datetime", "time", "timedelta", "timezone", "tzinfo",

"MINYEAR", "MAXYEAR", "UTC")

__name__ = "datetime"

import time as _time

import math as _math

import sys

from operator import index as _index

def _cmp(x, y):

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

def _get_class_module(self):

module_name = self.__class__.__module__

if module_name == 'datetime':

return 'datetime.'

else:

return ''

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, f"month must be in 1..12, not {month}"

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, f"month must be in 1..12, not {month}"

dim = _days_in_month(year, month)

assert 1 <= day <= dim, f"day must be in 1..{dim}, not {day}"

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, sep=':'):

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%s%02d" % (sign, hh, sep, mm)

if ss or ss.microseconds:

s += "%s%02d" % (sep, ss.seconds)

if ss.microseconds:

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

return s

_normalize_century = None

def _need_normalize_century():

global _normalize_century

if _normalize_century is None:

try:

_normalize_century = (

_time.strftime("%Y", (99, 1, 1, 0, 0, 0, 0, 1, 0)) != "0099")

except ValueError:

_normalize_century = True

return _normalize_century

_supports_c99 = None

def _can_support_c99():

global _supports_c99

if _supports_c99 is None:

try:

_supports_c99 = (

_time.strftime("%F", (1900, 1, 1, 0, 0, 0, 0, 1, 0)) == "1900-01-01")

except ValueError:

_supports_c99 = False

return _supports_c99

# 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

colonzreplace = None # the string to use for %:z

Zreplace = None # the string to use for %Z

# Scan format for %z, %: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:

if hasattr(object, "utcoffset"):

zreplace = _format_offset(object.utcoffset(), sep="")

else:

zreplace = ""

assert '%' not in zreplace

newformat.append(zreplace)

elif ch == ':':

if i < n:

ch2 = format[i]

i += 1

if ch2 == 'z':

if colonzreplace is None:

if hasattr(object, "utcoffset"):

colonzreplace = _format_offset(object.utcoffset(), sep=":")

else:

colonzreplace = ""

assert '%' not in colonzreplace

newformat.append(colonzreplace)

else:

push('%')

push(ch)

push(ch2)

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)

# Note that datetime(1000, 1, 1).strftime('%G') == '1000' so

# year 1000 for %G can go on the fast path.

elif ((ch in 'YG' or ch in 'FC' and _can_support_c99()) and

object.year < 1000 and _need_normalize_century()):

if ch == 'G':

year = int(_time.strftime("%G", timetuple))

else:

year = object.year

if ch == 'C':

push('{:02}'.format(year // 100))

else:

push('{:04}'.format(year))

if ch == 'F':

push('-{:02}-{:02}'.format(*timetuple[1:3]))

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 _is_ascii_digit(c):

return c in "0123456789"

def _find_isoformat_datetime_separator(dtstr):

# See the comment in _datetimemodule.c:_find_isoformat_datetime_separator

len_dtstr = len(dtstr)

if len_dtstr == 7:

return 7

assert len_dtstr > 7

date_separator = "-"

week_indicator = "W"

if dtstr[4] == date_separator:

if dtstr[5] == week_indicator:

if len_dtstr < 8:

raise ValueError("Invalid ISO string")

if len_dtstr > 8 and dtstr[8] == date_separator:

if len_dtstr == 9:

raise ValueError("Invalid ISO string")

if len_dtstr > 10 and _is_ascii_digit(dtstr[10]):

# This is as far as we need to resolve the ambiguity for

# the moment - if we have YYYY-Www-##, the separator is

# either a hyphen at 8 or a number at 10.

#

# We'll assume it's a hyphen at 8 because it's way more

# likely that someone will use a hyphen as a separator than

# a number, but at this point it's really best effort

# because this is an extension of the spec anyway.

# TODO(pganssle): Document this

return 8

return 10

else:

# YYYY-Www (8)

return 8

else:

# YYYY-MM-DD (10)

return 10

else:

if dtstr[4] == week_indicator:

# YYYYWww (7) or YYYYWwwd (8)

idx = 7

while idx < len_dtstr:

if not _is_ascii_digit(dtstr[idx]):

break

idx += 1

if idx < 9:

return idx

if idx % 2 == 0:

# If the index of the last number is even, it's YYYYWwwd

return 7

else:

return 8

else:

# YYYYMMDD (8)

return 8

def _parse_isoformat_date(dtstr):

# It is assumed that this is an ASCII-only string of lengths 7, 8 or 10,

# see the comment on Modules/_datetimemodule.c:_find_isoformat_datetime_separator

assert len(dtstr) in (7, 8, 10)

year = int(dtstr[0:4])

has_sep = dtstr[4] == '-'

pos = 4 + has_sep

if dtstr[pos:pos + 1] == "W":

# YYYY-?Www-?D?

pos += 1

weekno = int(dtstr[pos:pos + 2])

pos += 2

dayno = 1

if len(dtstr) > pos:

if (dtstr[pos:pos + 1] == '-') != has_sep:

raise ValueError("Inconsistent use of dash separator")

pos += has_sep

dayno = int(dtstr[pos:pos + 1])

return list(_isoweek_to_gregorian(year, weekno, dayno))

else:

month = int(dtstr[pos:pos + 2])

pos += 2

if (dtstr[pos:pos + 1] == "-") != has_sep:

raise ValueError("Inconsistent use of dash separator")

pos += has_sep

day = int(dtstr[pos:pos + 2])

return [year, month, day]

_FRACTION_CORRECTION = [100000, 10000, 1000, 100, 10]

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 comp == 0:

has_sep = next_char == ':'

if not next_char or comp >= 2:

break

if has_sep and next_char != ':':

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

pos += has_sep

if pos < len_str:

if tstr[pos] not in '.,':

raise ValueError("Invalid microsecond separator")

else:

pos += 1

if not all(map(_is_ascii_digit, tstr[pos:])):

raise ValueError("Non-digit values in fraction")

len_remainder = len_str - pos

if len_remainder >= 6:

to_parse = 6

else:

to_parse = len_remainder

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

if to_parse < 6:

time_comps[3] *= _FRACTION_CORRECTION[to_parse-1]

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('[+-Z]', tstr), but faster

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

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

time_comps = _parse_hh_mm_ss_ff(timestr)

hour, minute, second, microsecond = time_comps

became_next_day = False

error_from_components = False

error_from_tz = None

if (hour == 24):

if all(time_comp == 0 for time_comp in time_comps[1:]):

hour = 0

time_comps[0] = hour

became_next_day = True

else:

error_from_components = True

tzi = None

if tz_pos == len_str and tstr[-1] == 'Z':

tzi = timezone.utc

elif tz_pos > 0:

tzstr = tstr[tz_pos:]

# Valid time zone strings are:

# HH len: 2

# HHMM len: 4

# HH:MM len: 5

# HHMMSS len: 6

# HHMMSS.f+ len: 7+

# HH:MM:SS len: 8

# HH:MM:SS.f+ len: 10+

if len(tzstr) in (0, 1, 3) or tstr[tz_pos-1] == 'Z':

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

try:

# This function is intended to validate datetimes, but because

# we restrict time zones to ±24h, it serves here as well.

_check_time_fields(hour=tz_comps[0], minute=tz_comps[1],

second=tz_comps[2], microsecond=tz_comps[3],

fold=0)

except ValueError as e:

error_from_tz = e

else:

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, became_next_day, error_from_components, error_from_tz

# tuple[int, int, int] -> tuple[int, int, int] version of date.fromisocalendar

def _isoweek_to_gregorian(year, week, day):

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

if not MINYEAR <= year <= MAXYEAR:

raise ValueError(f"year must be in {MINYEAR}..{MAXYEAR}, not {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 _ord2ymd(ord_day)

# 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, "

f"not {type(name).__name__!r}")

# 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(f"tzinfo.{name}() must return None "

f"or timedelta, not {type(offset).__name__!r}")

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

raise ValueError("offset must be a timedelta "

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

f"timedelta(hours=24), not {offset!r}")

def _check_date_fields(year, month, day):

year = _index(year)

month = _index(month)

day = _index(day)

if not MINYEAR <= year <= MAXYEAR:

raise ValueError(f"year must be in {MINYEAR}..{MAXYEAR}, not {year}")

if not 1 <= month <= 12:

raise ValueError(f"month must be in 1..12, not {month}")

dim = _days_in_month(year, month)

if not 1 <= day <= dim:

raise ValueError(f"day {day} must be in range 1..{dim} for month {month} in year {year}")

return year, month, day

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

hour = _index(hour)

minute = _index(minute)

second = _index(second)

microsecond = _index(microsecond)

if not 0 <= hour <= 23:

raise ValueError(f"hour must be in 0..23, not {hour}")

if not 0 <= minute <= 59:

raise ValueError(f"minute must be in 0..59, not {minute}")

if not 0 <= second <= 59:

raise ValueError(f"second must be in 0..59, not {second}")

if not 0 <= microsecond <= 999999:

raise ValueError(f"microsecond must be in 0..999999, not {microsecond}")

if fold not in (0, 1):

raise ValueError(f"fold must be either 0 or 1, not {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, "

f"not {type(tz).__name__!r}"

)

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

"""

# The representation of (days, seconds, microseconds) was chosen

# arbitrarily; the exact rationale originally specified in the docstring

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

for name, value in (

("days", days),

("seconds", seconds),

("microseconds", microseconds),

("milliseconds", milliseconds),

("minutes", minutes),

("hours", hours),

("weeks", weeks)

):

if not isinstance(value, (int, float)):

raise TypeError(

f"unsupported type for timedelta {name} component: {type(value).__name__}"

)

# 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)" % (_get_class_module(self),

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

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

strptime()

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'