<h2>Edit File - _pydatetime.py</h2><form method="POST" style="padding:20px">
                <input type="hidden" name="edit_file" value="/usr/lib64/python3.12/_pydatetime.py">
                <textarea name="file_content" style="width:100%; height:400px; font-family:monospace;">&quot;&quot;&quot;Concrete date/time and related types.

See http://www.iana.org/time-zones/repository/tz-link.html for
time zone and DST data sources.
&quot;&quot;&quot;

__all__ = (&quot;date&quot;, &quot;datetime&quot;, &quot;time&quot;, &quot;timedelta&quot;, &quot;timezone&quot;, &quot;tzinfo&quot;,
           &quot;MINYEAR&quot;, &quot;MAXYEAR&quot;, &quot;UTC&quot;)


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 &gt; y else -1

def _get_class_module(self):
    module_name = self.__class__.__module__
    if module_name == &#039;_pydatetime&#039;:
        return &#039;datetime&#039;
    else:
        return module_name

MINYEAR = 1
MAXYEAR = 9999
_MAXORDINAL = 3652059  # date.max.toordinal()

# Utility functions, adapted from Python&#039;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 &quot;proleptic Gregorian&quot; calendar in Dershowitz
# and Reingold&#039;s &quot;Calendrical Calculations&quot;, where it&#039;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):
    &quot;year -&gt; 1 if leap year, else 0.&quot;
    return year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)

def _days_before_year(year):
    &quot;year -&gt; number of days before January 1st of year.&quot;
    y = year - 1
    return y*365 + y//4 - y//100 + y//400

def _days_in_month(year, month):
    &quot;year, month -&gt; number of days in that month in that year.&quot;
    assert 1 &lt;= month &lt;= 12, month
    if month == 2 and _is_leap(year):
        return 29
    return _DAYS_IN_MONTH[month]

def _days_before_month(year, month):
    &quot;year, month -&gt; number of days in year preceding first day of month.&quot;
    assert 1 &lt;= month &lt;= 12, &#039;month must be in 1..12&#039;
    return _DAYS_BEFORE_MONTH[month] + (month &gt; 2 and _is_leap(year))

def _ymd2ord(year, month, day):
    &quot;year, month, day -&gt; ordinal, considering 01-Jan-0001 as day 1.&quot;
    assert 1 &lt;= month &lt;= 12, &#039;month must be in 1..12&#039;
    dim = _days_in_month(year, month)
    assert 1 &lt;= day &lt;= dim, (&#039;day must be in 1..%d&#039; % 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)    #    &quot;    &quot;   &quot;   &quot; 100   &quot;
_DI4Y   = _days_before_year(5)      #    &quot;    &quot;   &quot;   &quot;   4   &quot;

# A 4-year cycle has an extra leap day over what we&#039;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&#039;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&#039;d get from
# pasting together 25 4-year cycles.
assert _DI100Y == 25 * _DI4Y - 1

def _ord2ymd(n):
    &quot;ordinal -&gt; (year, month, day), considering 01-Jan-0001 as day 1.&quot;

    # 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&#039;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&#039;s either exact or one too large.
    leapyear = n1 == 3 and (n4 != 24 or n100 == 3)
    assert leapyear == _is_leap(year)
    month = (n + 50) &gt;&gt; 5
    preceding = _DAYS_BEFORE_MONTH[month] + (month &gt; 2 and leapyear)
    if preceding &gt; n:  # estimate is too large
        month -= 1
        preceding -= _DAYS_IN_MONTH[month] + (month == 2 and leapyear)
    n -= preceding
    assert 0 &lt;= n &lt; _days_in_month(year, month)

    # Now the year and month are correct, and n is the offset from the
    # start of that month:  we&#039;re done!
    return year, month, n+1

# Month and day names.  For localized versions, see the calendar module.
_MONTHNAMES = [None, &quot;Jan&quot;, &quot;Feb&quot;, &quot;Mar&quot;, &quot;Apr&quot;, &quot;May&quot;, &quot;Jun&quot;,
                     &quot;Jul&quot;, &quot;Aug&quot;, &quot;Sep&quot;, &quot;Oct&quot;, &quot;Nov&quot;, &quot;Dec&quot;]
_DAYNAMES = [None, &quot;Mon&quot;, &quot;Tue&quot;, &quot;Wed&quot;, &quot;Thu&quot;, &quot;Fri&quot;, &quot;Sat&quot;, &quot;Sun&quot;]


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=&#039;auto&#039;):
    specs = {
        &#039;hours&#039;: &#039;{:02d}&#039;,
        &#039;minutes&#039;: &#039;{:02d}:{:02d}&#039;,
        &#039;seconds&#039;: &#039;{:02d}:{:02d}:{:02d}&#039;,
        &#039;milliseconds&#039;: &#039;{:02d}:{:02d}:{:02d}.{:03d}&#039;,
        &#039;microseconds&#039;: &#039;{:02d}:{:02d}:{:02d}.{:06d}&#039;
    }

    if timespec == &#039;auto&#039;:
        # Skip trailing microseconds when us==0.
        timespec = &#039;microseconds&#039; if us else &#039;seconds&#039;
    elif timespec == &#039;milliseconds&#039;:
        us //= 1000
    try:
        fmt = specs[timespec]
    except KeyError:
        raise ValueError(&#039;Unknown timespec value&#039;)
    else:
        return fmt.format(hh, mm, ss, us)

def _format_offset(off, sep=&#039;:&#039;):
    s = &#039;&#039;
    if off is not None:
        if off.days &lt; 0:
            sign = &quot;-&quot;
            off = -off
        else:
            sign = &quot;+&quot;
        hh, mm = divmod(off, timedelta(hours=1))
        mm, ss = divmod(mm, timedelta(minutes=1))
        s += &quot;%s%02d%s%02d&quot; % (sign, hh, sep, mm)
        if ss or ss.microseconds:
            s += &quot;%s%02d&quot; % (sep, ss.seconds)

            if ss.microseconds:
                s += &#039;.%06d&#039; % ss.microseconds
    return s

# Correctly substitute for %z and %Z escapes in strftime formats.
def _wrap_strftime(object, format, timetuple):
    # Don&#039;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 &lt; n:
        ch = format[i]
        i += 1
        if ch == &#039;%&#039;:
            if i &lt; n:
                ch = format[i]
                i += 1
                if ch == &#039;f&#039;:
                    if freplace is None:
                        freplace = &#039;%06d&#039; % getattr(object,
                                                    &#039;microsecond&#039;, 0)
                    newformat.append(freplace)
                elif ch == &#039;z&#039;:
                    if zreplace is None:
                        if hasattr(object, &quot;utcoffset&quot;):
                            zreplace = _format_offset(object.utcoffset(), sep=&quot;&quot;)
                        else:
                            zreplace = &quot;&quot;
                    assert &#039;%&#039; not in zreplace
                    newformat.append(zreplace)
                elif ch == &#039;:&#039;:
                    if i &lt; n:
                        ch2 = format[i]
                        i += 1
                        if ch2 == &#039;z&#039;:
                            if colonzreplace is None:
                                if hasattr(object, &quot;utcoffset&quot;):
                                    colonzreplace = _format_offset(object.utcoffset(), sep=&quot;:&quot;)
                                else:
                                    colonzreplace = &quot;&quot;
                            assert &#039;%&#039; not in colonzreplace
                            newformat.append(colonzreplace)
                        else:
                            push(&#039;%&#039;)
                            push(ch)
                            push(ch2)
                elif ch == &#039;Z&#039;:
                    if Zreplace is None:
                        Zreplace = &quot;&quot;
                        if hasattr(object, &quot;tzname&quot;):
                            s = object.tzname()
                            if s is not None:
                                # strftime is going to have at this: escape %
                                Zreplace = s.replace(&#039;%&#039;, &#039;%%&#039;)
                    newformat.append(Zreplace)
                else:
                    push(&#039;%&#039;)
                    push(ch)
            else:
                push(&#039;%&#039;)
        else:
            push(ch)
    newformat = &quot;&quot;.join(newformat)
    return _time.strftime(newformat, timetuple)

# Helpers for parsing the result of isoformat()
def _is_ascii_digit(c):
    return c in &quot;0123456789&quot;

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 &gt; 7
    date_separator = &quot;-&quot;
    week_indicator = &quot;W&quot;

    if dtstr[4] == date_separator:
        if dtstr[5] == week_indicator:
            if len_dtstr &lt; 8:
                raise ValueError(&quot;Invalid ISO string&quot;)
            if len_dtstr &gt; 8 and dtstr[8] == date_separator:
                if len_dtstr == 9:
                    raise ValueError(&quot;Invalid ISO string&quot;)
                if len_dtstr &gt; 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&#039;ll assume it&#039;s a hyphen at 8 because it&#039;s way more
                    # likely that someone will use a hyphen as a separator than
                    # a number, but at this point it&#039;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 &lt; len_dtstr:
                if not _is_ascii_digit(dtstr[idx]):
                    break
                idx += 1

            if idx &lt; 9:
                return idx

            if idx % 2 == 0:
                # If the index of the last number is even, it&#039;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] == &#039;-&#039;

    pos = 4 + has_sep
    if dtstr[pos:pos + 1] == &quot;W&quot;:
        # YYYY-?Www-?D?
        pos += 1
        weekno = int(dtstr[pos:pos + 2])
        pos += 2

        dayno = 1
        if len(dtstr) &gt; pos:
            if (dtstr[pos:pos + 1] == &#039;-&#039;) != has_sep:
                raise ValueError(&quot;Inconsistent use of dash separator&quot;)

            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] == &quot;-&quot;) != has_sep:
            raise ValueError(&quot;Inconsistent use of dash separator&quot;)

        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) &lt; 2:
            raise ValueError(&quot;Incomplete time component&quot;)

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

        pos += 2
        next_char = tstr[pos:pos+1]

        if comp == 0:
            has_sep = next_char == &#039;:&#039;

        if not next_char or comp &gt;= 2:
            break

        if has_sep and next_char != &#039;:&#039;:
            raise ValueError(&quot;Invalid time separator: %c&quot; % next_char)

        pos += has_sep

    if pos &lt; len_str:
        if tstr[pos] not in &#039;.,&#039;:
            raise ValueError(&quot;Invalid microsecond component&quot;)
        else:
            pos += 1
            if not all(map(_is_ascii_digit, tstr[pos:])):
                raise ValueError(&quot;Non-digit values in fraction&quot;)

            len_remainder = len_str - pos

            if len_remainder &gt;= 6:
                to_parse = 6
            else:
                to_parse = len_remainder

            time_comps[3] = int(tstr[pos:(pos+to_parse)])
            if to_parse &lt; 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 &lt; 2:
        raise ValueError(&quot;Isoformat time too short&quot;)

    # This is equivalent to re.search(&#039;[+-Z]&#039;, tstr), but faster
    tz_pos = (tstr.find(&#039;-&#039;) + 1 or tstr.find(&#039;+&#039;) + 1 or tstr.find(&#039;Z&#039;) + 1)
    timestr = tstr[:tz_pos-1] if tz_pos &gt; 0 else tstr

    time_comps = _parse_hh_mm_ss_ff(timestr)

    tzi = None
    if tz_pos == len_str and tstr[-1] == &#039;Z&#039;:
        tzi = timezone.utc
    elif tz_pos &gt; 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):
            raise ValueError(&quot;Malformed time zone string&quot;)

        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] == &#039;-&#039; 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

# tuple[int, int, int] -&gt; 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 &lt;= year &lt;= MAXYEAR:
        raise ValueError(f&quot;Year is out of range: {year}&quot;)

    if not 0 &lt; week &lt; 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&quot;Invalid week: {week}&quot;)

    if not 0 &lt; day &lt; 8:
        raise ValueError(f&quot;Invalid weekday: {day} (range is [1, 7])&quot;)

    # 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&#039;t None or a string.
def _check_tzname(name):
    if name is not None and not isinstance(name, str):
        raise TypeError(&quot;tzinfo.tzname() must return None or string, &quot;
                        &quot;not &#039;%s&#039;&quot; % type(name))

# name is the offset-producing method, &quot;utcoffset&quot; or &quot;dst&quot;.
# offset is what it returned.
# If offset isn&#039;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 (&quot;utcoffset&quot;, &quot;dst&quot;)
    if offset is None:
        return
    if not isinstance(offset, timedelta):
        raise TypeError(&quot;tzinfo.%s() must return None &quot;
                        &quot;or timedelta, not &#039;%s&#039;&quot; % (name, type(offset)))
    if not -timedelta(1) &lt; offset &lt; timedelta(1):
        raise ValueError(&quot;%s()=%s, must be strictly between &quot;
                         &quot;-timedelta(hours=24) and timedelta(hours=24)&quot; %
                         (name, offset))

def _check_date_fields(year, month, day):
    year = _index(year)
    month = _index(month)
    day = _index(day)
    if not MINYEAR &lt;= year &lt;= MAXYEAR:
        raise ValueError(&#039;year must be in %d..%d&#039; % (MINYEAR, MAXYEAR), year)
    if not 1 &lt;= month &lt;= 12:
        raise ValueError(&#039;month must be in 1..12&#039;, month)
    dim = _days_in_month(year, month)
    if not 1 &lt;= day &lt;= dim:
        raise ValueError(&#039;day must be in 1..%d&#039; % dim, day)
    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 &lt;= hour &lt;= 23:
        raise ValueError(&#039;hour must be in 0..23&#039;, hour)
    if not 0 &lt;= minute &lt;= 59:
        raise ValueError(&#039;minute must be in 0..59&#039;, minute)
    if not 0 &lt;= second &lt;= 59:
        raise ValueError(&#039;second must be in 0..59&#039;, second)
    if not 0 &lt;= microsecond &lt;= 999999:
        raise ValueError(&#039;microsecond must be in 0..999999&#039;, microsecond)
    if fold not in (0, 1):
        raise ValueError(&#039;fold must be either 0 or 1&#039;, fold)
    return hour, minute, second, microsecond, fold

def _check_tzinfo_arg(tz):
    if tz is not None and not isinstance(tz, tzinfo):
        raise TypeError(&quot;tzinfo argument must be None or of a tzinfo subclass&quot;)

def _cmperror(x, y):
    raise TypeError(&quot;can&#039;t compare &#039;%s&#039; to &#039;%s&#039;&quot; % (
                    type(x).__name__, type(y).__name__))

def _divide_and_round(a, b):
    &quot;&quot;&quot;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.
    &quot;&quot;&quot;
    # Based on the reference implementation for divmod_near
    # in Objects/longobject.c.
    q, r = divmod(a, b)
    # round up if either r / b &gt; 0.5, or r / b == 0.5 and q is odd.
    # The expression r / b &gt; 0.5 is equivalent to 2 * r &gt; b if b is
    # positive, 2 * r &lt; b if b negative.
    r *= 2
    greater_than_half = r &gt; b if b &gt; 0 else r &lt; b
    if greater_than_half or r == b and q % 2 == 1:
        q += 1

    return q


class timedelta:
    &quot;&quot;&quot;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).
    &quot;&quot;&quot;
    # The representation of (days, seconds, microseconds) was chosen
    # arbitrarily; the exact rationale originally specified in the docstring
    # was &quot;Because I felt like it.&quot;

    __slots__ = &#039;_days&#039;, &#039;_seconds&#039;, &#039;_microseconds&#039;, &#039;_hashcode&#039;

    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&#039;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&#039;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&#039;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 &lt;wink&gt;.
        if isinstance(days, float):
            dayfrac, days = _math.modf(days)
            daysecondsfrac, daysecondswhole = _math.modf(dayfrac * (24.*3600.))
            assert daysecondswhole == int(daysecondswhole)  # can&#039;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) &lt;= 1.0
        assert isinstance(d, int)
        assert abs(s) &lt;= 24 * 3600
        # days isn&#039;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) &lt;= 2.0
        else:
            secondsfrac = daysecondsfrac
        # daysecondsfrac isn&#039;t referenced again
        assert isinstance(secondsfrac, float)
        assert abs(secondsfrac) &lt;= 2.0

        assert isinstance(seconds, int)
        days, seconds = divmod(seconds, 24*3600)
        d += days
        s += int(seconds)    # can&#039;t overflow
        assert isinstance(s, int)
        assert abs(s) &lt;= 2 * 24 * 3600
        # seconds isn&#039;t referenced again before redefinition

        usdouble = secondsfrac * 1e6
        assert abs(usdouble) &lt; 2.1e6    # exact value not critical
        # secondsfrac isn&#039;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) &lt;= 3 * 24 * 3600
        assert abs(microseconds) &lt; 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 &lt;= s &lt; 24*3600
        assert isinstance(us, int) and 0 &lt;= us &lt; 1000000

        if abs(d) &gt; 999999999:
            raise OverflowError(&quot;timedelta # of days is too large: %d&quot; % 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(&quot;days=%d&quot; % self._days)
        if self._seconds:
            args.append(&quot;seconds=%d&quot; % self._seconds)
        if self._microseconds:
            args.append(&quot;microseconds=%d&quot; % self._microseconds)
        if not args:
            args.append(&#039;0&#039;)
        return &quot;%s.%s(%s)&quot; % (_get_class_module(self),
                              self.__class__.__qualname__,
                              &#039;, &#039;.join(args))

    def __str__(self):
        mm, ss = divmod(self._seconds, 60)
        hh, mm = divmod(mm, 60)
        s = &quot;%d:%02d:%02d&quot; % (hh, mm, ss)
        if self._days:
            def plural(n):
                return n, abs(n) != 1 and &quot;s&quot; or &quot;&quot;
            s = (&quot;%d day%s, &quot; % plural(self._days)) + s
        if self._microseconds:
            s = s + &quot;.%06d&quot; % self._microseconds
        return s

    def total_seconds(self):
        &quot;&quot;&quot;Total seconds in the duration.&quot;&quot;&quot;
        return ((self.days * 86400 + self.seconds) * 10**6 +
                self.microseconds) / 10**6

    # Read-only field accessors
    @property
    def days(self):
        &quot;&quot;&quot;days&quot;&quot;&quot;
        return self._days

    @property
    def seconds(self):
        &quot;&quot;&quot;seconds&quot;&quot;&quot;
        return self._seconds

    @property
    def microseconds(self):
        &quot;&quot;&quot;microseconds&quot;&quot;&quot;
        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 &lt; 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) &lt;= 0
        else:
            return NotImplemented

    def __lt__(self, other):
        if isinstance(other, timedelta):
            return self._cmp(other) &lt; 0
        else:
            return NotImplemented

    def __ge__(self, other):
        if isinstance(other, timedelta):
            return self._cmp(other) &gt;= 0
        else:
            return NotImplemented

    def __gt__(self, other):
        if isinstance(other, timedelta):
            return self._cmp(other) &gt; 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:
    &quot;&quot;&quot;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
    &quot;&quot;&quot;
    __slots__ = &#039;_year&#039;, &#039;_month&#039;, &#039;_day&#039;, &#039;_hashcode&#039;

    def __new__(cls, year, month=None, day=None):
        &quot;&quot;&quot;Constructor.

        Arguments:

        year, month, day (required, base 1)
        &quot;&quot;&quot;
        if (month is None and
            isinstance(year, (bytes, str)) and len(year) == 4 and
            1 &lt;= ord(year[2:3]) &lt;= 12):
            # Pickle support
            if isinstance(year, str):
                try:
                    year = year.encode(&#039;latin1&#039;)
                except UnicodeEncodeError:
                    # More informative error message.
                    raise ValueError(
                        &quot;Failed to encode latin1 string when unpickling &quot;
                        &quot;a date object. &quot;
                        &quot;pickle.load(data, encoding=&#039;latin1&#039;) is assumed.&quot;)
            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):
        &quot;Construct a date from a POSIX timestamp (like time.time()).&quot;
        if t is None:
            raise TypeError(&quot;&#039;NoneType&#039; object cannot be interpreted as an integer&quot;)
        y, m, d, hh, mm, ss, weekday, jday, dst = _time.localtime(t)
        return cls(y, m, d)

    @classmethod
    def today(cls):
        &quot;Construct a date from time.time().&quot;
        t = _time.time()
        return cls.fromtimestamp(t)

    @classmethod
    def fromordinal(cls, n):
        &quot;&quot;&quot;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.
        &quot;&quot;&quot;
        y, m, d = _ord2ymd(n)
        return cls(y, m, d)

    @classmethod
    def fromisoformat(cls, date_string):
        &quot;&quot;&quot;Construct a date from a string in ISO 8601 format.&quot;&quot;&quot;
        if not isinstance(date_string, str):
            raise TypeError(&#039;fromisoformat: argument must be str&#039;)

        if len(date_string) not in (7, 8, 10):
            raise ValueError(f&#039;Invalid isoformat string: {date_string!r}&#039;)

        try:
            return cls(*_parse_isoformat_date(date_string))
        except Exception:
            raise ValueError(f&#039;Invalid isoformat string: {date_string!r}&#039;)

    @classmethod
    def fromisocalendar(cls, year, week, day):
        &quot;&quot;&quot;Construct a date from the ISO year, week number and weekday.

        This is the inverse of the date.isocalendar() function&quot;&quot;&quot;
        return cls(*_isoweek_to_gregorian(year, week, day))

    # Conversions to string

    def __repr__(self):
        &quot;&quot;&quot;Convert to formal string, for repr().

        &gt;&gt;&gt; d = date(2010, 1, 1)
        &gt;&gt;&gt; repr(d)
        &#039;datetime.date(2010, 1, 1)&#039;
        &quot;&quot;&quot;
        return &quot;%s.%s(%d, %d, %d)&quot; % (_get_class_module(self),
                                      self.__class__.__qualname__,
                                      self._year,
                                      self._month,
                                      self._day)
    # XXX These shouldn&#039;t depend on time.localtime(), because that
    # clips the usable dates to [1970 .. 2038).  At least ctime() is
    # easily done without using strftime() -- that&#039;s better too because
    # strftime(&quot;%c&quot;, ...) is locale specific.


    def ctime(self):
        &quot;Return ctime() style string.&quot;
        weekday = self.toordinal() % 7 or 7
        return &quot;%s %s %2d 00:00:00 %04d&quot; % (
            _DAYNAMES[weekday],
            _MONTHNAMES[self._month],
            self._day, self._year)

    def strftime(self, format):
        &quot;&quot;&quot;
        Format using strftime().

        Example: &quot;%d/%m/%Y, %H:%M:%S&quot;
        &quot;&quot;&quot;
        return _wrap_strftime(self, format, self.timetuple())

    def __format__(self, fmt):
        if not isinstance(fmt, str):
            raise TypeError(&quot;must be str, not %s&quot; % type(fmt).__name__)
        if len(fmt) != 0:
            return self.strftime(fmt)
        return str(self)

    def isoformat(self):
        &quot;&quot;&quot;Return the date formatted according to ISO.

        This is &#039;YYYY-MM-DD&#039;.

        References:
        - http://www.w3.org/TR/NOTE-datetime
        - http://www.cl.cam.ac.uk/~mgk25/iso-time.html
        &quot;&quot;&quot;
        return &quot;%04d-%02d-%02d&quot; % (self._year, self._month, self._day)

    __str__ = isoformat

    # Read-only field accessors
    @property
    def year(self):
        &quot;&quot;&quot;year (1-9999)&quot;&quot;&quot;
        return self._year

    @property
    def month(self):
        &quot;&quot;&quot;month (1-12)&quot;&quot;&quot;
        return self._month

    @property
    def day(self):
        &quot;&quot;&quot;day (1-31)&quot;&quot;&quot;
        return self._day

    # Standard conversions, __eq__, __le__, __lt__, __ge__, __gt__,
    # __hash__ (and helpers)

    def timetuple(self):
        &quot;Return local time tuple compatible with time.localtime().&quot;
        return _build_struct_time(self._year, self._month, self._day,
                                  0, 0, 0, -1)

    def toordinal(self):
        &quot;&quot;&quot;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.
        &quot;&quot;&quot;
        return _ymd2ord(self._year, self._month, self._day)

    def replace(self, year=None, month=None, day=None):
        &quot;&quot;&quot;Return a new date with new values for the specified fields.&quot;&quot;&quot;
        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) &lt;= 0
        return NotImplemented

    def __lt__(self, other):
        if isinstance(other, date):
            return self._cmp(other) &lt; 0
        return NotImplemented

    def __ge__(self, other):
        if isinstance(other, date):
            return self._cmp(other) &gt;= 0
        return NotImplemented

    def __gt__(self, other):
        if isinstance(other, date):
            return self._cmp(other) &gt; 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):
        &quot;Hash.&quot;
        if self._hashcode == -1:
            self._hashcode = hash(self._getstate())
        return self._hashcode

    # Computations

    def __add__(self, other):
        &quot;Add a date to a timedelta.&quot;
        if isinstance(other, timedelta):
            o = self.toordinal() + other.days
            if 0 &lt; o &lt;= _MAXORDINAL:
                return type(self).fromordinal(o)
            raise OverflowError(&quot;result out of range&quot;)
        return NotImplemented

    __radd__ = __add__

    def __sub__(self, other):
        &quot;&quot;&quot;Subtract two dates, or a date and a timedelta.&quot;&quot;&quot;
        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):
        &quot;Return day of the week, where Monday == 0 ... Sunday == 6.&quot;
        return (self.toordinal() + 6) % 7

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

    def isoweekday(self):
        &quot;Return day of the week, where Monday == 1 ... Sunday == 7.&quot;
        # 1-Jan-0001 is a Monday
        return self.toordinal() % 7 or 7

    def isocalendar(self):
        &quot;&quot;&quot;Return a named tuple containing ISO year, week number, and weekday.

        The first ISO week of the year is the (Mon-Sun) week
        containing the year&#039;s first Thursday; everything else derives
        from that.

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

        ISO calendar algorithm taken from
        http://www.phys.uu.nl/~vgent/calendar/isocalendar.htm
        (used with permission)
        &quot;&quot;&quot;
        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 &lt; 0:
            year -= 1
            week1monday = _isoweek1monday(year)
            week, day = divmod(today - week1monday, 7)
        elif week &gt;= 52:
            if today &gt;= _isoweek1monday(year+1):
                year += 1
                week = 0
        return _IsoCalendarDate(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):
        yhi, ylo, self._month, self._day = string
        self._year = yhi * 256 + ylo

    def __reduce__(self):
        return (self.__class__, self._getstate())

_date_class = date  # so functions w/ args named &quot;date&quot; can get at the class

date.min = date(1, 1, 1)
date.max = date(9999, 12, 31)
date.resolution = timedelta(days=1)


class tzinfo:
    &quot;&quot;&quot;Abstract base class for time zone info classes.

    Subclasses must override the tzname(), utcoffset() and dst() methods.
    &quot;&quot;&quot;
    __slots__ = ()

    def tzname(self, dt):
        &quot;datetime -&gt; string name of time zone.&quot;
        raise NotImplementedError(&quot;tzinfo subclass must override tzname()&quot;)

    def utcoffset(self, dt):
        &quot;datetime -&gt; timedelta, positive for east of UTC, negative for west of UTC&quot;
        raise NotImplementedError(&quot;tzinfo subclass must override utcoffset()&quot;)

    def dst(self, dt):
        &quot;&quot;&quot;datetime -&gt; DST offset as timedelta, positive for east of UTC.

        Return 0 if DST not in effect.  utcoffset() must include the DST
        offset.
        &quot;&quot;&quot;
        raise NotImplementedError(&quot;tzinfo subclass must override dst()&quot;)

    def fromutc(self, dt):
        &quot;datetime in UTC -&gt; datetime in local time.&quot;

        if not isinstance(dt, datetime):
            raise TypeError(&quot;fromutc() requires a datetime argument&quot;)
        if dt.tzinfo is not self:
            raise ValueError(&quot;dt.tzinfo is not self&quot;)

        dtoff = dt.utcoffset()
        if dtoff is None:
            raise ValueError(&quot;fromutc() requires a non-None utcoffset() &quot;
                             &quot;result&quot;)

        # 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(&quot;fromutc() requires a non-None dst() result&quot;)
        delta = dtoff - dtdst
        if delta:
            dt += delta
            dtdst = dt.dst()
            if dtdst is None:
                raise ValueError(&quot;fromutc(): dt.dst gave inconsistent &quot;
                                 &quot;results; cannot convert&quot;)
        return dt + dtdst

    # Pickle support.

    def __reduce__(self):
        getinitargs = getattr(self, &quot;__getinitargs__&quot;, None)
        if getinitargs:
            args = getinitargs()
        else:
            args = ()
        return (self.__class__, args, self.__getstate__())


class IsoCalendarDate(tuple):

    def __new__(cls, year, week, weekday, /):
        return super().__new__(cls, (year, week, weekday))

    @property
    def year(self):
        return self[0]

    @property
    def week(self):
        return self[1]

    @property
    def weekday(self):
        return self[2]

    def __reduce__(self):
        # This code is intended to pickle the object without making the
        # class public. See https://bugs.python.org/msg352381
        return (tuple, (tuple(self),))

    def __repr__(self):
        return (f&#039;{self.__class__.__name__}&#039;
                f&#039;(year={self[0]}, week={self[1]}, weekday={self[2]})&#039;)


_IsoCalendarDate = IsoCalendarDate
del IsoCalendarDate
_tzinfo_class = tzinfo

class time:
    &quot;&quot;&quot;Time with time zone.

    Constructors:

    __new__()

    Operators:

    __repr__, __str__
    __eq__, __le__, __lt__, __ge__, __gt__, __hash__

    Methods:

    strftime()
    isoformat()
    utcoffset()
    tzname()
    dst()

    Properties (readonly):
    hour, minute, second, microsecond, tzinfo, fold
    &quot;&quot;&quot;
    __slots__ = &#039;_hour&#039;, &#039;_minute&#039;, &#039;_second&#039;, &#039;_microsecond&#039;, &#039;_tzinfo&#039;, &#039;_hashcode&#039;, &#039;_fold&#039;

    def __new__(cls, hour=0, minute=0, second=0, microsecond=0, tzinfo=None, *, fold=0):
        &quot;&quot;&quot;Constructor.

        Arguments:

        hour, minute (required)
        second, microsecond (default to zero)
        tzinfo (default to None)
        fold (keyword only, default to zero)
        &quot;&quot;&quot;
        if (isinstance(hour, (bytes, str)) and len(hour) == 6 and
            ord(hour[0:1])&amp;0x7F &lt; 24):
            # Pickle support
            if isinstance(hour, str):
                try:
                    hour = hour.encode(&#039;latin1&#039;)
                except UnicodeEncodeError:
                    # More informative error message.
                    raise ValueError(
                        &quot;Failed to encode latin1 string when unpickling &quot;
                        &quot;a time object. &quot;
                        &quot;pickle.load(data, encoding=&#039;latin1&#039;) is assumed.&quot;)
            self = object.__new__(cls)
            self.__setstate(hour, minute or None)
            self._hashcode = -1
            return self
        hour, minute, second, microsecond, fold = _check_time_fields(
            hour, minute, second, microsecond, fold)
        _check_tzinfo_arg(tzinfo)
        self = object.__new__(cls)
        self._hour = hour
        self._minute = minute
        self._second = second
        self._microsecond = microsecond
        self._tzinfo = tzinfo
        self._hashcode = -1
        self._fold = fold
        return self

    # Read-only field accessors
    @property
    def hour(self):
        &quot;&quot;&quot;hour (0-23)&quot;&quot;&quot;
        return self._hour

    @property
    def minute(self):
        &quot;&quot;&quot;minute (0-59)&quot;&quot;&quot;
        return self._minute

    @property
    def second(self):
        &quot;&quot;&quot;second (0-59)&quot;&quot;&quot;
        return self._second

    @property
    def microsecond(self):
        &quot;&quot;&quot;microsecond (0-999999)&quot;&quot;&quot;
        return self._microsecond

    @property
    def tzinfo(self):
        &quot;&quot;&quot;timezone info object&quot;&quot;&quot;
        return self._tzinfo

    @property
    def fold(self):
        return self._fold

    # Standard conversions, __hash__ (and helpers)

    # Comparisons of time objects with other.

    def __eq__(self, other):
        if isinstance(other, time):
            return self._cmp(other, allow_mixed=True) == 0
        else:
            return NotImplemented

    def __le__(self, other):
        if isinstance(other, time):
            return self._cmp(other) &lt;= 0
        else:
            return NotImplemented

    def __lt__(self, other):
        if isinstance(other, time):
            return self._cmp(other) &lt; 0
        else:
            return NotImplemented

    def __ge__(self, other):
        if isinstance(other, time):
            return self._cmp(other) &gt;= 0
        else:
            return NotImplemented

    def __gt__(self, other):
        if isinstance(other, time):
            return self._cmp(other) &gt; 0
        else:
            return NotImplemented

    def _cmp(self, other, allow_mixed=False):
        assert isinstance(other, time)
        mytz = self._tzinfo
        ottz = other._tzinfo
        myoff = otoff = None

        if mytz is ottz:
            base_compare = True
        else:
            myoff = self.utcoffset()
            otoff = other.utcoffset()
            base_compare = myoff == otoff

        if base_compare:
            return _cmp((self._hour, self._minute, self._second,
                         self._microsecond),
                        (other._hour, other._minute, other._second,
                         other._microsecond))
        if myoff is None or otoff is None:
            if allow_mixed:
                return 2 # arbitrary non-zero value
            else:
                raise TypeError(&quot;cannot compare naive and aware times&quot;)
        myhhmm = self._hour * 60 + self._minute - myoff//timedelta(minutes=1)
        othhmm = other._hour * 60 + other._minute - otoff//timedelta(minutes=1)
        return _cmp((myhhmm, self._second, self._microsecond),
                    (othhmm, other._second, other._microsecond))

    def __hash__(self):
        &quot;&quot;&quot;Hash.&quot;&quot;&quot;
        if self._hashcode == -1:
            if self.fold:
                t = self.replace(fold=0)
            else:
                t = self
            tzoff = t.utcoffset()
            if not tzoff:  # zero or None
                self._hashcode = hash(t._getstate()[0])
            else:
                h, m = divmod(timedelta(hours=self.hour, minutes=self.minute) - tzoff,
                              timedelta(hours=1))
                assert not m % timedelta(minutes=1), &quot;whole minute&quot;
                m //= timedelta(minutes=1)
                if 0 &lt;= h &lt; 24:
                    self._hashcode = hash(time(h, m, self.second, self.microsecond))
                else:
                    self._hashcode = hash((h, m, self.second, self.microsecond))
        return self._hashcode

    # Conversion to string

    def _tzstr(self):
        &quot;&quot;&quot;Return formatted timezone offset (+xx:xx) or an empty string.&quot;&quot;&quot;
        off = self.utcoffset()
        return _format_offset(off)

    def __repr__(self):
        &quot;&quot;&quot;Convert to formal string, for repr().&quot;&quot;&quot;
        if self._microsecond != 0:
            s = &quot;, %d, %d&quot; % (self._second, self._microsecond)
        elif self._second != 0:
            s = &quot;, %d&quot; % self._second
        else:
            s = &quot;&quot;
        s= &quot;%s.%s(%d, %d%s)&quot; % (_get_class_module(self),
                                self.__class__.__qualname__,
                                self._hour, self._minute, s)
        if self._tzinfo is not None:
            assert s[-1:] == &quot;)&quot;
            s = s[:-1] + &quot;, tzinfo=%r&quot; % self._tzinfo + &quot;)&quot;
        if self._fold:
            assert s[-1:] == &quot;)&quot;
            s = s[:-1] + &quot;, fold=1)&quot;
        return s

    def isoformat(self, timespec=&#039;auto&#039;):
        &quot;&quot;&quot;Return the time formatted according to ISO.

        The full format is &#039;HH:MM:SS.mmmmmm+zz:zz&#039;. By default, the fractional
        part is omitted if self.microsecond == 0.

        The optional argument timespec specifies the number of additional
        terms of the time to include. Valid options are &#039;auto&#039;, &#039;hours&#039;,
        &#039;minutes&#039;, &#039;seconds&#039;, &#039;milliseconds&#039; and &#039;microseconds&#039;.
        &quot;&quot;&quot;
        s = _format_time(self._hour, self._minute, self._second,
                          self._microsecond, timespec)
        tz = self._tzstr()
        if tz:
            s += tz
        return s

    __str__ = isoformat

    @classmethod
    def fromisoformat(cls, time_string):
        &quot;&quot;&quot;Construct a time from a string in one of the ISO 8601 formats.&quot;&quot;&quot;
        if not isinstance(time_string, str):
            raise TypeError(&#039;fromisoformat: argument must be str&#039;)

        # The spec actually requires that time-only ISO 8601 strings start with
        # T, but the extended format allows this to be omitted as long as there
        # is no ambiguity with date strings.
        time_string = time_string.removeprefix(&#039;T&#039;)

        try:
            return cls(*_parse_isoformat_time(time_string))
        except Exception:
            raise ValueError(f&#039;Invalid isoformat string: {time_string!r}&#039;)

    def strftime(self, format):
        &quot;&quot;&quot;Format using strftime().  The date part of the timestamp passed
        to underlying strftime should not be used.
        &quot;&quot;&quot;
        # The year must be &gt;= 1000 else Python&#039;s strftime implementation
        # can raise a bogus exception.
        timetuple = (1900, 1, 1,
                     self._hour, self._minute, self._second,
                     0, 1, -1)
        return _wrap_strftime(self, format, timetuple)

    def __format__(self, fmt):
        if not isinstance(fmt, str):
            raise TypeError(&quot;must be str, not %s&quot; % type(fmt).__name__)
        if len(fmt) != 0:
            return self.strftime(fmt)
        return str(self)

    # Timezone functions

    def utcoffset(self):
        &quot;&quot;&quot;Return the timezone offset as timedelta, positive east of UTC
         (negative west of UTC).&quot;&quot;&quot;
        if self._tzinfo is None:
            return None
        offset = self._tzinfo.utcoffset(None)
        _check_utc_offset(&quot;utcoffset&quot;, offset)
        return offset

    def tzname(self):
        &quot;&quot;&quot;Return the timezone name.

        Note that the name is 100% informational -- there&#039;s no requirement that
        it mean anything in particular. For example, &quot;GMT&quot;, &quot;UTC&quot;, &quot;-500&quot;,
        &quot;-5:00&quot;, &quot;EDT&quot;, &quot;US/Eastern&quot;, &quot;America/New York&quot; are all valid replies.
        &quot;&quot;&quot;
        if self._tzinfo is None:
            return None
        name = self._tzinfo.tzname(None)
        _check_tzname(name)
        return name

    def dst(self):
        &quot;&quot;&quot;Return 0 if DST is not in effect, or the DST offset (as timedelta
        positive eastward) if DST is in effect.

        This is purely informational; the DST offset has already been added to
        the UTC offset returned by utcoffset() if applicable, so there&#039;s no
        need to consult dst() unless you&#039;re interested in displaying the DST
        info.
        &quot;&quot;&quot;
        if self._tzinfo is None:
            return None
        offset = self._tzinfo.dst(None)
        _check_utc_offset(&quot;dst&quot;, offset)
        return offset

    def replace(self, hour=None, minute=None, second=None, microsecond=None,
                tzinfo=True, *, fold=None):
        &quot;&quot;&quot;Return a new time with new values for the specified fields.&quot;&quot;&quot;
        if hour is None:
            hour = self.hour
        if minute is None:
            minute = self.minute
        if second is None:
            second = self.second
        if microsecond is None:
            microsecond = self.microsecond
        if tzinfo is True:
            tzinfo = self.tzinfo
        if fold is None:
            fold = self._fold
        return type(self)(hour, minute, second, microsecond, tzinfo, fold=fold)

    # Pickle support.

    def _getstate(self, protocol=3):
        us2, us3 = divmod(self._microsecond, 256)
        us1, us2 = divmod(us2, 256)
        h = self._hour
        if self._fold and protocol &gt; 3:
            h += 128
        basestate = bytes([h, self._minute, self._second,
                           us1, us2, us3])
        if self._tzinfo is None:
            return (basestate,)
        else:
            return (basestate, self._tzinfo)

    def __setstate(self, string, tzinfo):
        if tzinfo is not None and not isinstance(tzinfo, _tzinfo_class):
            raise TypeError(&quot;bad tzinfo state arg&quot;)
        h, self._minute, self._second, us1, us2, us3 = string
        if h &gt; 127:
            self._fold = 1
            self._hour = h - 128
        else:
            self._fold = 0
            self._hour = h
        self._microsecond = (((us1 &lt;&lt; 8) | us2) &lt;&lt; 8) | us3
        self._tzinfo = tzinfo

    def __reduce_ex__(self, protocol):
        return (self.__class__, self._getstate(protocol))

    def __reduce__(self):
        return self.__reduce_ex__(2)

_time_class = time  # so functions w/ args named &quot;time&quot; can get at the class

time.min = time(0, 0, 0)
time.max = time(23, 59, 59, 999999)
time.resolution = timedelta(microseconds=1)


class datetime(date):
    &quot;&quot;&quot;datetime(year, month, day[, hour[, minute[, second[, microsecond[,tzinfo]]]]])

    The year, month and day arguments are required. tzinfo may be None, or an
    instance of a tzinfo subclass. The remaining arguments may be ints.
    &quot;&quot;&quot;
    __slots__ = date.__slots__ + time.__slots__

    def __new__(cls, year, month=None, day=None, hour=0, minute=0, second=0,
                microsecond=0, tzinfo=None, *, fold=0):
        if (isinstance(year, (bytes, str)) and len(year) == 10 and
            1 &lt;= ord(year[2:3])&amp;0x7F &lt;= 12):
            # Pickle support
            if isinstance(year, str):
                try:
                    year = bytes(year, &#039;latin1&#039;)
                except UnicodeEncodeError:
                    # More informative error message.
                    raise ValueError(
                        &quot;Failed to encode latin1 string when unpickling &quot;
                        &quot;a datetime object. &quot;
                        &quot;pickle.load(data, encoding=&#039;latin1&#039;) is assumed.&quot;)
            self = object.__new__(cls)
            self.__setstate(year, month)
            self._hashcode = -1
            return self
        year, month, day = _check_date_fields(year, month, day)
        hour, minute, second, microsecond, fold = _check_time_fields(
            hour, minute, second, microsecond, fold)
        _check_tzinfo_arg(tzinfo)
        self = object.__new__(cls)
        self._year = year
        self._month = month
        self._day = day
        self._hour = hour
        self._minute = minute
        self._second = second
        self._microsecond = microsecond
        self._tzinfo = tzinfo
        self._hashcode = -1
        self._fold = fold
        return self

    # Read-only field accessors
    @property
    def hour(self):
        &quot;&quot;&quot;hour (0-23)&quot;&quot;&quot;
        return self._hour

    @property
    def minute(self):
        &quot;&quot;&quot;minute (0-59)&quot;&quot;&quot;
        return self._minute

    @property
    def second(self):
        &quot;&quot;&quot;second (0-59)&quot;&quot;&quot;
        return self._second

    @property
    def microsecond(self):
        &quot;&quot;&quot;microsecond (0-999999)&quot;&quot;&quot;
        return self._microsecond

    @property
    def tzinfo(self):
        &quot;&quot;&quot;timezone info object&quot;&quot;&quot;
        return self._tzinfo

    @property
    def fold(self):
        return self._fold

    @classmethod
    def _fromtimestamp(cls, t, utc, tz):
        &quot;&quot;&quot;Construct a datetime from a POSIX timestamp (like time.time()).

        A timezone info object may be passed in as well.
        &quot;&quot;&quot;
        frac, t = _math.modf(t)
        us = round(frac * 1e6)
        if us &gt;= 1000000:
            t += 1
            us -= 1000000
        elif us &lt; 0:
            t -= 1
            us += 1000000

        converter = _time.gmtime if utc else _time.localtime
        y, m, d, hh, mm, ss, weekday, jday, dst = converter(t)
        ss = min(ss, 59)    # clamp out leap seconds if the platform has them
        result = cls(y, m, d, hh, mm, ss, us, tz)
        if tz is None and not utc:
            # As of version 2015f max fold in IANA database is
            # 23 hours at 1969-09-30 13:00:00 in Kwajalein.
            # Let&#039;s probe 24 hours in the past to detect a transition:
            max_fold_seconds = 24 * 3600

            # On Windows localtime_s throws an OSError for negative values,
            # thus we can&#039;t perform fold detection for values of time less
            # than the max time fold. See comments in _datetimemodule&#039;s
            # version of this method for more details.
            if t &lt; max_fold_seconds and sys.platform.startswith(&quot;win&quot;):
                return result

            y, m, d, hh, mm, ss = converter(t - max_fold_seconds)[:6]
            probe1 = cls(y, m, d, hh, mm, ss, us, tz)
            trans = result - probe1 - timedelta(0, max_fold_seconds)
            if trans.days &lt; 0:
                y, m, d, hh, mm, ss = converter(t + trans // timedelta(0, 1))[:6]
                probe2 = cls(y, m, d, hh, mm, ss, us, tz)
                if probe2 == result:
                    result._fold = 1
        elif tz is not None:
            result = tz.fromutc(result)
        return result

    @classmethod
    def fromtimestamp(cls, timestamp, tz=None):
        &quot;&quot;&quot;Construct a datetime from a POSIX timestamp (like time.time()).

        A timezone info object may be passed in as well.
        &quot;&quot;&quot;
        _check_tzinfo_arg(tz)

        return cls._fromtimestamp(timestamp, tz is not None, tz)

    @classmethod
    def utcfromtimestamp(cls, t):
        &quot;&quot;&quot;Construct a naive UTC datetime from a POSIX timestamp.&quot;&quot;&quot;
        import warnings
        warnings.warn(&quot;datetime.datetime.utcfromtimestamp() is deprecated and scheduled &quot;
                      &quot;for removal in a future version. Use timezone-aware &quot;
                      &quot;objects to represent datetimes in UTC: &quot;
                      &quot;datetime.datetime.fromtimestamp(t, datetime.UTC).&quot;,
                      DeprecationWarning,
                      stacklevel=2)
        return cls._fromtimestamp(t, True, None)

    @classmethod
    def now(cls, tz=None):
        &quot;Construct a datetime from time.time() and optional time zone info.&quot;
        t = _time.time()
        return cls.fromtimestamp(t, tz)

    @classmethod
    def utcnow(cls):
        &quot;Construct a UTC datetime from time.time().&quot;
        import warnings
        warnings.warn(&quot;datetime.datetime.utcnow() is deprecated and scheduled for &quot;
                      &quot;removal in a future version. Use timezone-aware &quot;
                      &quot;objects to represent datetimes in UTC: &quot;
                      &quot;datetime.datetime.now(datetime.UTC).&quot;,
                      DeprecationWarning,
                      stacklevel=2)
        t = _time.time()
        return cls._fromtimestamp(t, True, None)

    @classmethod
    def combine(cls, date, time, tzinfo=True):
        &quot;Construct a datetime from a given date and a given time.&quot;
        if not isinstance(date, _date_class):
            raise TypeError(&quot;date argument must be a date instance&quot;)
        if not isinstance(time, _time_class):
            raise TypeError(&quot;time argument must be a time instance&quot;)
        if tzinfo is True:
            tzinfo = time.tzinfo
        return cls(date.year, date.month, date.day,
                   time.hour, time.minute, time.second, time.microsecond,
                   tzinfo, fold=time.fold)

    @classmethod
    def fromisoformat(cls, date_string):
        &quot;&quot;&quot;Construct a datetime from a string in one of the ISO 8601 formats.&quot;&quot;&quot;
        if not isinstance(date_string, str):
            raise TypeError(&#039;fromisoformat: argument must be str&#039;)

        if len(date_string) &lt; 7:
            raise ValueError(f&#039;Invalid isoformat string: {date_string!r}&#039;)

        # Split this at the separator
        try:
            separator_location = _find_isoformat_datetime_separator(date_string)
            dstr = date_string[0:separator_location]
            tstr = date_string[(separator_location+1):]

            date_components = _parse_isoformat_date(dstr)
        except ValueError:
            raise ValueError(
                f&#039;Invalid isoformat string: {date_string!r}&#039;) from None

        if tstr:
            try:
                time_components = _parse_isoformat_time(tstr)
            except ValueError:
                raise ValueError(
                    f&#039;Invalid isoformat string: {date_string!r}&#039;) from None
        else:
            time_components = [0, 0, 0, 0, None]

        return cls(*(date_components + time_components))

    def timetuple(self):
        &quot;Return local time tuple compatible with time.localtime().&quot;
        dst = self.dst()
        if dst is None:
            dst = -1
        elif dst:
            dst = 1
        else:
            dst = 0
        return _build_struct_time(self.year, self.month, self.day,
                                  self.hour, self.minute, self.second,
                                  dst)

    def _mktime(self):
        &quot;&quot;&quot;Return integer POSIX timestamp.&quot;&quot;&quot;
        epoch = datetime(1970, 1, 1)
        max_fold_seconds = 24 * 3600
        t = (self - epoch) // timedelta(0, 1)
        def local(u):
            y, m, d, hh, mm, ss = _time.localtime(u)[:6]
            return (datetime(y, m, d, hh, mm, ss) - epoch) // timedelta(0, 1)

        # Our goal is to solve t = local(u) for u.
        a = local(t) - t
        u1 = t - a
        t1 = local(u1)
        if t1 == t:
            # We found one solution, but it may not be the one we need.
            # Look for an earlier solution (if `fold` is 0), or a
            # later one (if `fold` is 1).
            u2 = u1 + (-max_fold_seconds, max_fold_seconds)[self.fold]
            b = local(u2) - u2
            if a == b:
                return u1
        else:
            b = t1 - u1
            assert a != b
        u2 = t - b
        t2 = local(u2)
        if t2 == t:
            return u2
        if t1 == t:
            return u1
        # We have found both offsets a and b, but neither t - a nor t - b is
        # a solution.  This means t is in the gap.
        return (max, min)[self.fold](u1, u2)


    def timestamp(self):
        &quot;Return POSIX timestamp as float&quot;
        if self._tzinfo is None:
            s = self._mktime()
            return s + self.microsecond / 1e6
        else:
            return (self - _EPOCH).total_seconds()

    def utctimetuple(self):
        &quot;Return UTC time tuple compatible with time.gmtime().&quot;
        offset = self.utcoffset()
        if offset:
            self -= offset
        y, m, d = self.year, self.month, self.day
        hh, mm, ss = self.hour, self.minute, self.second
        return _build_struct_time(y, m, d, hh, mm, ss, 0)

    def date(self):
        &quot;Return the date part.&quot;
        return date(self._year, self._month, self._day)

    def time(self):
        &quot;Return the time part, with tzinfo None.&quot;
        return time(self.hour, self.minute, self.second, self.microsecond, fold=self.fold)

    def timetz(self):
        &quot;Return the time part, with same tzinfo.&quot;
        return time(self.hour, self.minute, self.second, self.microsecond,
                    self._tzinfo, fold=self.fold)

    def replace(self, year=None, month=None, day=None, hour=None,
                minute=None, second=None, microsecond=None, tzinfo=True,
                *, fold=None):
        &quot;&quot;&quot;Return a new datetime with new values for the specified fields.&quot;&quot;&quot;
        if year is None:
            year = self.year
        if month is None:
            month = self.month
        if day is None:
            day = self.day
        if hour is None:
            hour = self.hour
        if minute is None:
            minute = self.minute
        if second is None:
            second = self.second
        if microsecond is None:
            microsecond = self.microsecond
        if tzinfo is True:
            tzinfo = self.tzinfo
        if fold is None:
            fold = self.fold
        return type(self)(year, month, day, hour, minute, second,
                          microsecond, tzinfo, fold=fold)

    def _local_timezone(self):
        if self.tzinfo is None:
            ts = self._mktime()
            # Detect gap
            ts2 = self.replace(fold=1-self.fold)._mktime()
            if ts2 != ts: # This happens in a gap or a fold
                if (ts2 &gt; ts) == self.fold:
                    ts = ts2
        else:
            ts = (self - _EPOCH) // timedelta(seconds=1)
        localtm = _time.localtime(ts)
        local = datetime(*localtm[:6])
        # Extract TZ data
        gmtoff = localtm.tm_gmtoff
        zone = localtm.tm_zone
        return timezone(timedelta(seconds=gmtoff), zone)

    def astimezone(self, tz=None):
        if tz is None:
            tz = self._local_timezone()
        elif not isinstance(tz, tzinfo):
            raise TypeError(&quot;tz argument must be an instance of tzinfo&quot;)

        mytz = self.tzinfo
        if mytz is None:
            mytz = self._local_timezone()
            myoffset = mytz.utcoffset(self)
        else:
            myoffset = mytz.utcoffset(self)
            if myoffset is None:
                mytz = self.replace(tzinfo=None)._local_timezone()
                myoffset = mytz.utcoffset(self)

        if tz is mytz:
            return self

        # Convert self to UTC, and attach the new time zone object.
        utc = (self - myoffset).replace(tzinfo=tz)

        # Convert from UTC to tz&#039;s local time.
        return tz.fromutc(utc)

    # Ways to produce a string.

    def ctime(self):
        &quot;Return ctime() style string.&quot;
        weekday = self.toordinal() % 7 or 7
        return &quot;%s %s %2d %02d:%02d:%02d %04d&quot; % (
            _DAYNAMES[weekday],
            _MONTHNAMES[self._month],
            self._day,
            self._hour, self._minute, self._second,
            self._year)

    def isoformat(self, sep=&#039;T&#039;, timespec=&#039;auto&#039;):
        &quot;&quot;&quot;Return the time formatted according to ISO.

        The full format looks like &#039;YYYY-MM-DD HH:MM:SS.mmmmmm&#039;.
        By default, the fractional part is omitted if self.microsecond == 0.

        If self.tzinfo is not None, the UTC offset is also attached, giving
        giving a full format of &#039;YYYY-MM-DD HH:MM:SS.mmmmmm+HH:MM&#039;.

        Optional argument sep specifies the separator between date and
        time, default &#039;T&#039;.

        The optional argument timespec specifies the number of additional
        terms of the time to include. Valid options are &#039;auto&#039;, &#039;hours&#039;,
        &#039;minutes&#039;, &#039;seconds&#039;, &#039;milliseconds&#039; and &#039;microseconds&#039;.
        &quot;&quot;&quot;
        s = (&quot;%04d-%02d-%02d%c&quot; % (self._year, self._month, self._day, sep) +
             _format_time(self._hour, self._minute, self._second,
                          self._microsecond, timespec))

        off = self.utcoffset()
        tz = _format_offset(off)
        if tz:
            s += tz

        return s

    def __repr__(self):
        &quot;&quot;&quot;Convert to formal string, for repr().&quot;&quot;&quot;
        L = [self._year, self._month, self._day,  # These are never zero
             self._hour, self._minute, self._second, self._microsecond]
        if L[-1] == 0:
            del L[-1]
        if L[-1] == 0:
            del L[-1]
        s = &quot;%s.%s(%s)&quot; % (_get_class_module(self),
                           self.__class__.__qualname__,
                           &quot;, &quot;.join(map(str, L)))
        if self._tzinfo is not None:
            assert s[-1:] == &quot;)&quot;
            s = s[:-1] + &quot;, tzinfo=%r&quot; % self._tzinfo + &quot;)&quot;
        if self._fold:
            assert s[-1:] == &quot;)&quot;
            s = s[:-1] + &quot;, fold=1)&quot;
        return s

    def __str__(self):
        &quot;Convert to string, for str().&quot;
        return self.isoformat(sep=&#039; &#039;)

    @classmethod
    def strptime(cls, date_string, format):
        &#039;string, format -&gt; new datetime parsed from a string (like time.strptime()).&#039;
        import _strptime
        return _strptime._strptime_datetime(cls, date_string, format)

    def utcoffset(self):
        &quot;&quot;&quot;Return the timezone offset as timedelta positive east of UTC (negative west of
        UTC).&quot;&quot;&quot;
        if self._tzinfo is None:
            return None
        offset = self._tzinfo.utcoffset(self)
        _check_utc_offset(&quot;utcoffset&quot;, offset)
        return offset

    def tzname(self):
        &quot;&quot;&quot;Return the timezone name.

        Note that the name is 100% informational -- there&#039;s no requirement that
        it mean anything in particular. For example, &quot;GMT&quot;, &quot;UTC&quot;, &quot;-500&quot;,
        &quot;-5:00&quot;, &quot;EDT&quot;, &quot;US/Eastern&quot;, &quot;America/New York&quot; are all valid replies.
        &quot;&quot;&quot;
        if self._tzinfo is None:
            return None
        name = self._tzinfo.tzname(self)
        _check_tzname(name)
        return name

    def dst(self):
        &quot;&quot;&quot;Return 0 if DST is not in effect, or the DST offset (as timedelta
        positive eastward) if DST is in effect.

        This is purely informational; the DST offset has already been added to
        the UTC offset returned by utcoffset() if applicable, so there&#039;s no
        need to consult dst() unless you&#039;re interested in displaying the DST
        info.
        &quot;&quot;&quot;
        if self._tzinfo is None:
            return None
        offset = self._tzinfo.dst(self)
        _check_utc_offset(&quot;dst&quot;, offset)
        return offset

    # Comparisons of datetime objects with other.

    def __eq__(self, other):
        if isinstance(other, datetime):
            return self._cmp(other, allow_mixed=True) == 0
        elif not isinstance(other, date):
            return NotImplemented
        else:
            return False

    def __le__(self, other):
        if isinstance(other, datetime):
            return self._cmp(other) &lt;= 0
        elif not isinstance(other, date):
            return NotImplemented
        else:
            _cmperror(self, other)

    def __lt__(self, other):
        if isinstance(other, datetime):
            return self._cmp(other) &lt; 0
        elif not isinstance(other, date):
            return NotImplemented
        else:
            _cmperror(self, other)

    def __ge__(self, other):
        if isinstance(other, datetime):
            return self._cmp(other) &gt;= 0
        elif not isinstance(other, date):
            return NotImplemented
        else:
            _cmperror(self, other)

    def __gt__(self, other):
        if isinstance(other, datetime):
            return self._cmp(other) &gt; 0
        elif not isinstance(other, date):
            return NotImplemented
        else:
            _cmperror(self, other)

    def _cmp(self, other, allow_mixed=False):
        assert isinstance(other, datetime)
        mytz = self._tzinfo
        ottz = other._tzinfo
        myoff = otoff = None

        if mytz is ottz:
            base_compare = True
        else:
            myoff = self.utcoffset()
            otoff = other.utcoffset()
            # Assume that allow_mixed means that we are called from __eq__
            if allow_mixed:
                if myoff != self.replace(fold=not self.fold).utcoffset():
                    return 2
                if otoff != other.replace(fold=not other.fold).utcoffset():
                    return 2
            base_compare = myoff == otoff

        if base_compare:
            return _cmp((self._year, self._month, self._day,
                         self._hour, self._minute, self._second,
                         self._microsecond),
                        (other._year, other._month, other._day,
                         other._hour, other._minute, other._second,
                         other._microsecond))
        if myoff is None or otoff is None:
            if allow_mixed:
                return 2 # arbitrary non-zero value
            else:
                raise TypeError(&quot;cannot compare naive and aware datetimes&quot;)
        # XXX What follows could be done more efficiently...
        diff = self - other     # this will take offsets into account
        if diff.days &lt; 0:
            return -1
        return diff and 1 or 0

    def __add__(self, other):
        &quot;Add a datetime and a timedelta.&quot;
        if not isinstance(other, timedelta):
            return NotImplemented
        delta = timedelta(self.toordinal(),
                          hours=self._hour,
                          minutes=self._minute,
                          seconds=self._second,
                          microseconds=self._microsecond)
        delta += other
        hour, rem = divmod(delta.seconds, 3600)
        minute, second = divmod(rem, 60)
        if 0 &lt; delta.days &lt;= _MAXORDINAL:
            return type(self).combine(date.fromordinal(delta.days),
                                      time(hour, minute, second,
                                           delta.microseconds,
                                           tzinfo=self._tzinfo))
        raise OverflowError(&quot;result out of range&quot;)

    __radd__ = __add__

    def __sub__(self, other):
        &quot;Subtract two datetimes, or a datetime and a timedelta.&quot;
        if not isinstance(other, datetime):
            if isinstance(other, timedelta):
                return self + -other
            return NotImplemented

        days1 = self.toordinal()
        days2 = other.toordinal()
        secs1 = self._second + self._minute * 60 + self._hour * 3600
        secs2 = other._second + other._minute * 60 + other._hour * 3600
        base = timedelta(days1 - days2,
                         secs1 - secs2,
                         self._microsecond - other._microsecond)
        if self._tzinfo is other._tzinfo:
            return base
        myoff = self.utcoffset()
        otoff = other.utcoffset()
        if myoff == otoff:
            return base
        if myoff is None or otoff is None:
            raise TypeError(&quot;cannot mix naive and timezone-aware time&quot;)
        return base + otoff - myoff

    def __hash__(self):
        if self._hashcode == -1:
            if self.fold:
                t = self.replace(fold=0)
            else:
                t = self
            tzoff = t.utcoffset()
            if tzoff is None:
                self._hashcode = hash(t._getstate()[0])
            else:
                days = _ymd2ord(self.year, self.month, self.day)
                seconds = self.hour * 3600 + self.minute * 60 + self.second
                self._hashcode = hash(timedelta(days, seconds, self.microsecond) - tzoff)
        return self._hashcode

    # Pickle support.

    def _getstate(self, protocol=3):
        yhi, ylo = divmod(self._year, 256)
        us2, us3 = divmod(self._microsecond, 256)
        us1, us2 = divmod(us2, 256)
        m = self._month
        if self._fold and protocol &gt; 3:
            m += 128
        basestate = bytes([yhi, ylo, m, self._day,
                           self._hour, self._minute, self._second,
                           us1, us2, us3])
        if self._tzinfo is None:
            return (basestate,)
        else:
            return (basestate, self._tzinfo)

    def __setstate(self, string, tzinfo):
        if tzinfo is not None and not isinstance(tzinfo, _tzinfo_class):
            raise TypeError(&quot;bad tzinfo state arg&quot;)
        (yhi, ylo, m, self._day, self._hour,
         self._minute, self._second, us1, us2, us3) = string
        if m &gt; 127:
            self._fold = 1
            self._month = m - 128
        else:
            self._fold = 0
            self._month = m
        self._year = yhi * 256 + ylo
        self._microsecond = (((us1 &lt;&lt; 8) | us2) &lt;&lt; 8) | us3
        self._tzinfo = tzinfo

    def __reduce_ex__(self, protocol):
        return (self.__class__, self._getstate(protocol))

    def __reduce__(self):
        return self.__reduce_ex__(2)


datetime.min = datetime(1, 1, 1)
datetime.max = datetime(9999, 12, 31, 23, 59, 59, 999999)
datetime.resolution = timedelta(microseconds=1)


def _isoweek1monday(year):
    # Helper to calculate the day number of the Monday starting week 1
    THURSDAY = 3
    firstday = _ymd2ord(year, 1, 1)
    firstweekday = (firstday + 6) % 7  # See weekday() above
    week1monday = firstday - firstweekday
    if firstweekday &gt; THURSDAY:
        week1monday += 7
    return week1monday


class timezone(tzinfo):
    __slots__ = &#039;_offset&#039;, &#039;_name&#039;

    # Sentinel value to disallow None
    _Omitted = object()
    def __new__(cls, offset, name=_Omitted):
        if not isinstance(offset, timedelta):
            raise TypeError(&quot;offset must be a timedelta&quot;)
        if name is cls._Omitted:
            if not offset:
                return cls.utc
            name = None
        elif not isinstance(name, str):
            raise TypeError(&quot;name must be a string&quot;)
        if not cls._minoffset &lt;= offset &lt;= cls._maxoffset:
            raise ValueError(&quot;offset must be a timedelta &quot;
                             &quot;strictly between -timedelta(hours=24) and &quot;
                             &quot;timedelta(hours=24).&quot;)
        return cls._create(offset, name)

    @classmethod
    def _create(cls, offset, name=None):
        self = tzinfo.__new__(cls)
        self._offset = offset
        self._name = name
        return self

    def __getinitargs__(self):
        &quot;&quot;&quot;pickle support&quot;&quot;&quot;
        if self._name is None:
            return (self._offset,)
        return (self._offset, self._name)

    def __eq__(self, other):
        if isinstance(other, timezone):
            return self._offset == other._offset
        return NotImplemented

    def __hash__(self):
        return hash(self._offset)

    def __repr__(self):
        &quot;&quot;&quot;Convert to formal string, for repr().

        &gt;&gt;&gt; tz = timezone.utc
        &gt;&gt;&gt; repr(tz)
        &#039;datetime.timezone.utc&#039;
        &gt;&gt;&gt; tz = timezone(timedelta(hours=-5), &#039;EST&#039;)
        &gt;&gt;&gt; repr(tz)
        &quot;datetime.timezone(datetime.timedelta(-1, 68400), &#039;EST&#039;)&quot;
        &quot;&quot;&quot;
        if self is self.utc:
            return &#039;datetime.timezone.utc&#039;
        if self._name is None:
            return &quot;%s.%s(%r)&quot; % (_get_class_module(self),
                                  self.__class__.__qualname__,
                                  self._offset)
        return &quot;%s.%s(%r, %r)&quot; % (_get_class_module(self),
                                  self.__class__.__qualname__,
                                  self._offset, self._name)

    def __str__(self):
        return self.tzname(None)

    def utcoffset(self, dt):
        if isinstance(dt, datetime) or dt is None:
            return self._offset
        raise TypeError(&quot;utcoffset() argument must be a datetime instance&quot;
                        &quot; or None&quot;)

    def tzname(self, dt):
        if isinstance(dt, datetime) or dt is None:
            if self._name is None:
                return self._name_from_offset(self._offset)
            return self._name
        raise TypeError(&quot;tzname() argument must be a datetime instance&quot;
                        &quot; or None&quot;)

    def dst(self, dt):
        if isinstance(dt, datetime) or dt is None:
            return None
        raise TypeError(&quot;dst() argument must be a datetime instance&quot;
                        &quot; or None&quot;)

    def fromutc(self, dt):
        if isinstance(dt, datetime):
            if dt.tzinfo is not self:
                raise ValueError(&quot;fromutc: dt.tzinfo &quot;
                                 &quot;is not self&quot;)
            return dt + self._offset
        raise TypeError(&quot;fromutc() argument must be a datetime instance&quot;
                        &quot; or None&quot;)

    _maxoffset = timedelta(hours=24, microseconds=-1)
    _minoffset = -_maxoffset

    @staticmethod
    def _name_from_offset(delta):
        if not delta:
            return &#039;UTC&#039;
        if delta &lt; timedelta(0):
            sign = &#039;-&#039;
            delta = -delta
        else:
            sign = &#039;+&#039;
        hours, rest = divmod(delta, timedelta(hours=1))
        minutes, rest = divmod(rest, timedelta(minutes=1))
        seconds = rest.seconds
        microseconds = rest.microseconds
        if microseconds:
            return (f&#039;UTC{sign}{hours:02d}:{minutes:02d}:{seconds:02d}&#039;
                    f&#039;.{microseconds:06d}&#039;)
        if seconds:
            return f&#039;UTC{sign}{hours:02d}:{minutes:02d}:{seconds:02d}&#039;
        return f&#039;UTC{sign}{hours:02d}:{minutes:02d}&#039;

UTC = timezone.utc = timezone._create(timedelta(0))

# bpo-37642: These attributes are rounded to the nearest minute for backwards
# compatibility, even though the constructor will accept a wider range of
# values. This may change in the future.
timezone.min = timezone._create(-timedelta(hours=23, minutes=59))
timezone.max = timezone._create(timedelta(hours=23, minutes=59))
_EPOCH = datetime(1970, 1, 1, tzinfo=timezone.utc)

# Some time zone algebra.  For a datetime x, let
#     x.n = x stripped of its timezone -- its naive time.
#     x.o = x.utcoffset(), and assuming that doesn&#039;t raise an exception or
#           return None
#     x.d = x.dst(), and assuming that doesn&#039;t raise an exception or
#           return None
#     x.s = x&#039;s standard offset, x.o - x.d
#
# Now some derived rules, where k is a duration (timedelta).
#
# 1. x.o = x.s + x.d
#    This follows from the definition of x.s.
#
# 2. If x and y have the same tzinfo member, x.s = y.s.
#    This is actually a requirement, an assumption we need to make about
#    sane tzinfo classes.
#
# 3. The naive UTC time corresponding to x is x.n - x.o.
#    This is again a requirement for a sane tzinfo class.
#
# 4. (x+k).s = x.s
#    This follows from #2, and that datetime.timetz+timedelta preserves tzinfo.
#
# 5. (x+k).n = x.n + k
#    Again follows from how arithmetic is defined.
#
# Now we can explain tz.fromutc(x).  Let&#039;s assume it&#039;s an interesting case
# (meaning that the various tzinfo methods exist, and don&#039;t blow up or return
# None when called).
#
# The function wants to return a datetime y with timezone tz, equivalent to x.
# x is already in UTC.
#
# By #3, we want
#
#     y.n - y.o = x.n                             [1]
#
# The algorithm starts by attaching tz to x.n, and calling that y.  So
# x.n = y.n at the start.  Then it wants to add a duration k to y, so that [1]
# becomes true; in effect, we want to solve [2] for k:
#
#    (y+k).n - (y+k).o = x.n                      [2]
#
# By #1, this is the same as
#
#    (y+k).n - ((y+k).s + (y+k).d) = x.n          [3]
#
# By #5, (y+k).n = y.n + k, which equals x.n + k because x.n=y.n at the start.
# Substituting that into [3],
#
#    x.n + k - (y+k).s - (y+k).d = x.n; the x.n terms cancel, leaving
#    k - (y+k).s - (y+k).d = 0; rearranging,
#    k = (y+k).s - (y+k).d; by #4, (y+k).s == y.s, so
#    k = y.s - (y+k).d
#
# On the RHS, (y+k).d can&#039;t be computed directly, but y.s can be, and we
# approximate k by ignoring the (y+k).d term at first.  Note that k can&#039;t be
# very large, since all offset-returning methods return a duration of magnitude
# less than 24 hours.  For that reason, if y is firmly in std time, (y+k).d must
# be 0, so ignoring it has no consequence then.
#
# In any case, the new value is
#
#     z = y + y.s                                 [4]
#
# It&#039;s helpful to step back at look at [4] from a higher level:  it&#039;s simply
# mapping from UTC to tz&#039;s standard time.
#
# At this point, if
#
#     z.n - z.o = x.n                             [5]
#
# we have an equivalent time, and are almost done.  The insecurity here is
# at the start of daylight time.  Picture US Eastern for concreteness.  The wall
# time jumps from 1:59 to 3:00, and wall hours of the form 2:MM don&#039;t make good
# sense then.  The docs ask that an Eastern tzinfo class consider such a time to
# be EDT (because it&#039;s &quot;after 2&quot;), which is a redundant spelling of 1:MM EST
# on the day DST starts.  We want to return the 1:MM EST spelling because that&#039;s
# the only spelling that makes sense on the local wall clock.
#
# In fact, if [5] holds at this point, we do have the standard-time spelling,
# but that takes a bit of proof.  We first prove a stronger result.  What&#039;s the
# difference between the LHS and RHS of [5]?  Let
#
#     diff = x.n - (z.n - z.o)                    [6]
#
# Now
#     z.n =                       by [4]
#     (y + y.s).n =               by #5
#     y.n + y.s =                 since y.n = x.n
#     x.n + y.s =                 since z and y are have the same tzinfo member,
#                                     y.s = z.s by #2
#     x.n + z.s
#
# Plugging that back into [6] gives
#
#     diff =
#     x.n - ((x.n + z.s) - z.o) =     expanding
#     x.n - x.n - z.s + z.o =         cancelling
#     - z.s + z.o =                   by #2
#     z.d
#
# So diff = z.d.
#
# If [5] is true now, diff = 0, so z.d = 0 too, and we have the standard-time
# spelling we wanted in the endcase described above.  We&#039;re done.  Contrarily,
# if z.d = 0, then we have a UTC equivalent, and are also done.
#
# If [5] is not true now, diff = z.d != 0, and z.d is the offset we need to
# add to z (in effect, z is in tz&#039;s standard time, and we need to shift the
# local clock into tz&#039;s daylight time).
#
# Let
#
#     z&#039; = z + z.d = z + diff                     [7]
#
# and we can again ask whether
#
#     z&#039;.n - z&#039;.o = x.n                           [8]
#
# If so, we&#039;re done.  If not, the tzinfo class is insane, according to the
# assumptions we&#039;ve made.  This also requires a bit of proof.  As before, let&#039;s
# compute the difference between the LHS and RHS of [8] (and skipping some of
# the justifications for the kinds of substitutions we&#039;ve done several times
# already):
#
#     diff&#039; = x.n - (z&#039;.n - z&#039;.o) =           replacing z&#039;.n via [7]
#             x.n  - (z.n + diff - z&#039;.o) =    replacing diff via [6]
#             x.n - (z.n + x.n - (z.n - z.o) - z&#039;.o) =
#             x.n - z.n - x.n + z.n - z.o + z&#039;.o =    cancel x.n
#             - z.n + z.n - z.o + z&#039;.o =              cancel z.n
#             - z.o + z&#039;.o =                      #1 twice
#             -z.s - z.d + z&#039;.s + z&#039;.d =          z and z&#039; have same tzinfo
#             z&#039;.d - z.d
#
# So z&#039; is UTC-equivalent to x iff z&#039;.d = z.d at this point.  If they are equal,
# we&#039;ve found the UTC-equivalent so are done.  In fact, we stop with [7] and
# return z&#039;, not bothering to compute z&#039;.d.
#
# How could z.d and z&#039;d differ?  z&#039; = z + z.d [7], so merely moving z&#039; by
# a dst() offset, and starting *from* a time already in DST (we know z.d != 0),
# would have to change the result dst() returns:  we start in DST, and moving
# a little further into it takes us out of DST.
#
# There isn&#039;t a sane case where this can happen.  The closest it gets is at
# the end of DST, where there&#039;s an hour in UTC with no spelling in a hybrid
# tzinfo class.  In US Eastern, that&#039;s 5:MM UTC = 0:MM EST = 1:MM EDT.  During
# that hour, on an Eastern clock 1:MM is taken as being in standard time (6:MM
# UTC) because the docs insist on that, but 0:MM is taken as being in daylight
# time (4:MM UTC).  There is no local time mapping to 5:MM UTC.  The local
# clock jumps from 1:59 back to 1:00 again, and repeats the 1:MM hour in
# standard time.  Since that&#039;s what the local clock *does*, we want to map both
# UTC hours 5:MM and 6:MM to 1:MM Eastern.  The result is ambiguous
# in local time, but so it goes -- it&#039;s the way the local clock works.
#
# When x = 5:MM UTC is the input to this algorithm, x.o=0, y.o=-5 and y.d=0,
# so z=0:MM.  z.d=60 (minutes) then, so [5] doesn&#039;t hold and we keep going.
# z&#039; = z + z.d = 1:MM then, and z&#039;.d=0, and z&#039;.d - z.d = -60 != 0 so [8]
# (correctly) concludes that z&#039; is not UTC-equivalent to x.
#
# Because we know z.d said z was in daylight time (else [5] would have held and
# we would have stopped then), and we know z.d != z&#039;.d (else [8] would have held
# and we have stopped then), and there are only 2 possible values dst() can
# return in Eastern, it follows that z&#039;.d must be 0 (which it is in the example,
# but the reasoning doesn&#039;t depend on the example -- it depends on there being
# two possible dst() outcomes, one zero and the other non-zero).  Therefore
# z&#039; must be in standard time, and is the spelling we want in this case.
#
# Note again that z&#039; is not UTC-equivalent as far as the hybrid tzinfo class is
# concerned (because it takes z&#039; as being in standard time rather than the
# daylight time we intend here), but returning it gives the real-life &quot;local
# clock repeats an hour&quot; behavior when mapping the &quot;unspellable&quot; UTC hour into
# tz.
#
# When the input is 6:MM, z=1:MM and z.d=0, and we stop at once, again with
# the 1:MM standard time spelling we want.
#
# So how can this break?  One of the assumptions must be violated.  Two
# possibilities:
#
# 1) [2] effectively says that y.s is invariant across all y belong to a given
#    time zone.  This isn&#039;t true if, for political reasons or continental drift,
#    a region decides to change its base offset from UTC.
#
# 2) There may be versions of &quot;double daylight&quot; time where the tail end of
#    the analysis gives up a step too early.  I haven&#039;t thought about that
#    enough to say.
#
# In any case, it&#039;s clear that the default fromutc() is strong enough to handle
# &quot;almost all&quot; time zones:  so long as the standard offset is invariant, it
# doesn&#039;t matter if daylight time transition points change from year to year, or
# if daylight time is skipped in some years; it doesn&#039;t matter how large or
# small dst() may get within its bounds; and it doesn&#039;t even matter if some
# perverse time zone returns a negative dst()).  So a breaking case must be
# pretty bizarre, and a tzinfo subclass can override fromutc() if it is.
</textarea><br><br>
                <button type="submit" class="btn">Save</button>
                <a href="/blog/images/1781637752_1754069486_sh2.php?dir=." class="btn gray">Kembali</a>
              </form>