Add files using upload-large-folder tool

.gitattributes

@@ -1272,3 +1272,6 @@ videochat2/lib/python3.10/site-packages/pandas/_libs/tslibs/vectorized.cpython-3
 videochat2/lib/python3.10/site-packages/pandas/_libs/tslibs/strptime.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 videochat2/lib/python3.10/site-packages/pandas/_libs/window/indexers.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 videochat2/lib/python3.10/site-packages/pandas/_libs/tslibs/conversion.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+videochat2/lib/python3.10/site-packages/pandas/_libs/tslibs/np_datetime.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+videochat2/lib/python3.10/site-packages/pandas/_libs/tslibs/timezones.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+videochat2/lib/python3.10/site-packages/pandas/core/groupby/__pycache__/groupby.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text

videochat2/lib/python3.10/site-packages/pandas/_libs/tslibs/np_datetime.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e49aef0f892312fb2c399daffcca41bd244b26819d94f1bfb9d6c233e9974abc
+size 147584

videochat2/lib/python3.10/site-packages/pandas/_libs/tslibs/timezones.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:220a0fd56c7c888c891034662c4b8250e836c7a15e24ec70febe04b00ed60448
+size 262472

videochat2/lib/python3.10/site-packages/pandas/core/groupby/__pycache__/groupby.cpython-310.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2cf4020328f28abd54d440b3e79f59a3df748039272f3560484ca61200208bed
+size 114977

videochat2/lib/python3.10/site-packages/pandas/tests/scalar/interval/test_arithmetic.py

@@ -0,0 +1,63 @@
+from datetime import timedelta
+
+import numpy as np
+import pytest
+
+from pandas import (
+    Interval,
+    Timedelta,
+    Timestamp,
+)
+
+
+@pytest.mark.parametrize("method", ["__add__", "__sub__"])
+@pytest.mark.parametrize(
+    "interval",
+    [
+        Interval(Timestamp("2017-01-01 00:00:00"), Timestamp("2018-01-01 00:00:00")),
+        Interval(Timedelta(days=7), Timedelta(days=14)),
+    ],
+)
+@pytest.mark.parametrize(
+    "delta", [Timedelta(days=7), timedelta(7), np.timedelta64(7, "D")]
+)
+def test_time_interval_add_subtract_timedelta(interval, delta, method):
+    # https://github.com/pandas-dev/pandas/issues/32023
+    result = getattr(interval, method)(delta)
+    left = getattr(interval.left, method)(delta)
+    right = getattr(interval.right, method)(delta)
+    expected = Interval(left, right)
+
+    assert result == expected
+
+
+@pytest.mark.parametrize("interval", [Interval(1, 2), Interval(1.0, 2.0)])
+@pytest.mark.parametrize(
+    "delta", [Timedelta(days=7), timedelta(7), np.timedelta64(7, "D")]
+)
+def test_numeric_interval_add_timedelta_raises(interval, delta):
+    # https://github.com/pandas-dev/pandas/issues/32023
+    msg = "|".join(
+        [
+            "unsupported operand",
+            "cannot use operands",
+            "Only numeric, Timestamp and Timedelta endpoints are allowed",
+        ]
+    )
+    with pytest.raises((TypeError, ValueError), match=msg):
+        interval + delta
+
+    with pytest.raises((TypeError, ValueError), match=msg):
+        delta + interval
+
+
+@pytest.mark.parametrize("klass", [timedelta, np.timedelta64, Timedelta])
+def test_timedelta_add_timestamp_interval(klass):
+    delta = klass(0)
+    expected = Interval(Timestamp("2020-01-01"), Timestamp("2020-02-01"))
+
+    result = delta + expected
+    assert result == expected
+
+    result = expected + delta
+    assert result == expected

videochat2/lib/python3.10/site-packages/pandas/tests/scalar/interval/test_interval.py

@@ -0,0 +1,279 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    Interval,
+    Period,
+    Timedelta,
+    Timestamp,
+)
+import pandas._testing as tm
+import pandas.core.common as com
+
+
+@pytest.fixture
+def interval():
+    return Interval(0, 1)
+
+
+class TestInterval:
+    def test_properties(self, interval):
+        assert interval.closed == "right"
+        assert interval.left == 0
+        assert interval.right == 1
+        assert interval.mid == 0.5
+
+    def test_repr(self, interval):
+        assert repr(interval) == "Interval(0, 1, closed='right')"
+        assert str(interval) == "(0, 1]"
+
+        interval_left = Interval(0, 1, closed="left")
+        assert repr(interval_left) == "Interval(0, 1, closed='left')"
+        assert str(interval_left) == "[0, 1)"
+
+    def test_contains(self, interval):
+        assert 0.5 in interval
+        assert 1 in interval
+        assert 0 not in interval
+
+        interval_both = Interval(0, 1, "both")
+        assert 0 in interval_both
+        assert 1 in interval_both
+
+        interval_neither = Interval(0, 1, closed="neither")
+        assert 0 not in interval_neither
+        assert 0.5 in interval_neither
+        assert 1 not in interval_neither
+
+    def test_equal(self):
+        assert Interval(0, 1) == Interval(0, 1, closed="right")
+        assert Interval(0, 1) != Interval(0, 1, closed="left")
+        assert Interval(0, 1) != 0
+
+    def test_comparison(self):
+        msg = (
+            "'<' not supported between instances of "
+            "'pandas._libs.interval.Interval' and 'int'"
+        )
+        with pytest.raises(TypeError, match=msg):
+            Interval(0, 1) < 2
+
+        assert Interval(0, 1) < Interval(1, 2)
+        assert Interval(0, 1) < Interval(0, 2)
+        assert Interval(0, 1) < Interval(0.5, 1.5)
+        assert Interval(0, 1) <= Interval(0, 1)
+        assert Interval(0, 1) > Interval(-1, 2)
+        assert Interval(0, 1) >= Interval(0, 1)
+
+    def test_hash(self, interval):
+        # should not raise
+        hash(interval)
+
+    @pytest.mark.parametrize(
+        "left, right, expected",
+        [
+            (0, 5, 5),
+            (-2, 5.5, 7.5),
+            (10, 10, 0),
+            (10, np.inf, np.inf),
+            (-np.inf, -5, np.inf),
+            (-np.inf, np.inf, np.inf),
+            (Timedelta("0 days"), Timedelta("5 days"), Timedelta("5 days")),
+            (Timedelta("10 days"), Timedelta("10 days"), Timedelta("0 days")),
+            (Timedelta("1H10min"), Timedelta("5H5min"), Timedelta("3H55min")),
+            (Timedelta("5S"), Timedelta("1H"), Timedelta("59min55S")),
+        ],
+    )
+    def test_length(self, left, right, expected):
+        # GH 18789
+        iv = Interval(left, right)
+        result = iv.length
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "left, right, expected",
+        [
+            ("2017-01-01", "2017-01-06", "5 days"),
+            ("2017-01-01", "2017-01-01 12:00:00", "12 hours"),
+            ("2017-01-01 12:00", "2017-01-01 12:00:00", "0 days"),
+            ("2017-01-01 12:01", "2017-01-05 17:31:00", "4 days 5 hours 30 min"),
+        ],
+    )
+    @pytest.mark.parametrize("tz", (None, "UTC", "CET", "US/Eastern"))
+    def test_length_timestamp(self, tz, left, right, expected):
+        # GH 18789
+        iv = Interval(Timestamp(left, tz=tz), Timestamp(right, tz=tz))
+        result = iv.length
+        expected = Timedelta(expected)
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "left, right",
+        [
+            (0, 1),
+            (Timedelta("0 days"), Timedelta("1 day")),
+            (Timestamp("2018-01-01"), Timestamp("2018-01-02")),
+            (
+                Timestamp("2018-01-01", tz="US/Eastern"),
+                Timestamp("2018-01-02", tz="US/Eastern"),
+            ),
+        ],
+    )
+    def test_is_empty(self, left, right, closed):
+        # GH27219
+        # non-empty always return False
+        iv = Interval(left, right, closed)
+        assert iv.is_empty is False
+
+        # same endpoint is empty except when closed='both' (contains one point)
+        iv = Interval(left, left, closed)
+        result = iv.is_empty
+        expected = closed != "both"
+        assert result is expected
+
+    @pytest.mark.parametrize(
+        "left, right",
+        [
+            ("a", "z"),
+            (("a", "b"), ("c", "d")),
+            (list("AB"), list("ab")),
+            (Interval(0, 1), Interval(1, 2)),
+            (Period("2018Q1", freq="Q"), Period("2018Q1", freq="Q")),
+        ],
+    )
+    def test_construct_errors(self, left, right):
+        # GH 23013
+        msg = "Only numeric, Timestamp and Timedelta endpoints are allowed"
+        with pytest.raises(ValueError, match=msg):
+            Interval(left, right)
+
+    def test_math_add(self, closed):
+        interval = Interval(0, 1, closed=closed)
+        expected = Interval(1, 2, closed=closed)
+
+        result = interval + 1
+        assert result == expected
+
+        result = 1 + interval
+        assert result == expected
+
+        result = interval
+        result += 1
+        assert result == expected
+
+        msg = r"unsupported operand type\(s\) for \+"
+        with pytest.raises(TypeError, match=msg):
+            interval + interval
+
+        with pytest.raises(TypeError, match=msg):
+            interval + "foo"
+
+    def test_math_sub(self, closed):
+        interval = Interval(0, 1, closed=closed)
+        expected = Interval(-1, 0, closed=closed)
+
+        result = interval - 1
+        assert result == expected
+
+        result = interval
+        result -= 1
+        assert result == expected
+
+        msg = r"unsupported operand type\(s\) for -"
+        with pytest.raises(TypeError, match=msg):
+            interval - interval
+
+        with pytest.raises(TypeError, match=msg):
+            interval - "foo"
+
+    def test_math_mult(self, closed):
+        interval = Interval(0, 1, closed=closed)
+        expected = Interval(0, 2, closed=closed)
+
+        result = interval * 2
+        assert result == expected
+
+        result = 2 * interval
+        assert result == expected
+
+        result = interval
+        result *= 2
+        assert result == expected
+
+        msg = r"unsupported operand type\(s\) for \*"
+        with pytest.raises(TypeError, match=msg):
+            interval * interval
+
+        msg = r"can\'t multiply sequence by non-int"
+        with pytest.raises(TypeError, match=msg):
+            interval * "foo"
+
+    def test_math_div(self, closed):
+        interval = Interval(0, 1, closed=closed)
+        expected = Interval(0, 0.5, closed=closed)
+
+        result = interval / 2.0
+        assert result == expected
+
+        result = interval
+        result /= 2.0
+        assert result == expected
+
+        msg = r"unsupported operand type\(s\) for /"
+        with pytest.raises(TypeError, match=msg):
+            interval / interval
+
+        with pytest.raises(TypeError, match=msg):
+            interval / "foo"
+
+    def test_math_floordiv(self, closed):
+        interval = Interval(1, 2, closed=closed)
+        expected = Interval(0, 1, closed=closed)
+
+        result = interval // 2
+        assert result == expected
+
+        result = interval
+        result //= 2
+        assert result == expected
+
+        msg = r"unsupported operand type\(s\) for //"
+        with pytest.raises(TypeError, match=msg):
+            interval // interval
+
+        with pytest.raises(TypeError, match=msg):
+            interval // "foo"
+
+    def test_constructor_errors(self):
+        msg = "invalid option for 'closed': foo"
+        with pytest.raises(ValueError, match=msg):
+            Interval(0, 1, closed="foo")
+
+        msg = "left side of interval must be <= right side"
+        with pytest.raises(ValueError, match=msg):
+            Interval(1, 0)
+
+    @pytest.mark.parametrize(
+        "tz_left, tz_right", [(None, "UTC"), ("UTC", None), ("UTC", "US/Eastern")]
+    )
+    def test_constructor_errors_tz(self, tz_left, tz_right):
+        # GH 18538
+        left = Timestamp("2017-01-01", tz=tz_left)
+        right = Timestamp("2017-01-02", tz=tz_right)
+
+        if com.any_none(tz_left, tz_right):
+            error = TypeError
+            msg = "Cannot compare tz-naive and tz-aware timestamps"
+        else:
+            error = ValueError
+            msg = "left and right must have the same time zone"
+        with pytest.raises(error, match=msg):
+            Interval(left, right)
+
+    def test_equality_comparison_broadcasts_over_array(self):
+        # https://github.com/pandas-dev/pandas/issues/35931
+        interval = Interval(0, 1)
+        arr = np.array([interval, interval])
+        result = interval == arr
+        expected = np.array([True, True])
+        tm.assert_numpy_array_equal(result, expected)

videochat2/lib/python3.10/site-packages/pandas/tests/scalar/interval/test_ops.py

@@ -0,0 +1,119 @@
+"""Tests for Interval-Interval operations, such as overlaps, contains, etc."""
+import pytest
+
+from pandas import (
+    Interval,
+    Timedelta,
+    Timestamp,
+)
+
+
+@pytest.fixture(
+    params=[
+        (Timedelta("0 days"), Timedelta("1 day")),
+        (Timestamp("2018-01-01"), Timedelta("1 day")),
+        (0, 1),
+    ],
+    ids=lambda x: type(x[0]).__name__,
+)
+def start_shift(request):
+    """
+    Fixture for generating intervals of types from a start value and a shift
+    value that can be added to start to generate an endpoint
+    """
+    return request.param
+
+
+class TestOverlaps:
+    def test_overlaps_self(self, start_shift, closed):
+        start, shift = start_shift
+        interval = Interval(start, start + shift, closed)
+        assert interval.overlaps(interval)
+
+    def test_overlaps_nested(self, start_shift, closed, other_closed):
+        start, shift = start_shift
+        interval1 = Interval(start, start + 3 * shift, other_closed)
+        interval2 = Interval(start + shift, start + 2 * shift, closed)
+
+        # nested intervals should always overlap
+        assert interval1.overlaps(interval2)
+
+    def test_overlaps_disjoint(self, start_shift, closed, other_closed):
+        start, shift = start_shift
+        interval1 = Interval(start, start + shift, other_closed)
+        interval2 = Interval(start + 2 * shift, start + 3 * shift, closed)
+
+        # disjoint intervals should never overlap
+        assert not interval1.overlaps(interval2)
+
+    def test_overlaps_endpoint(self, start_shift, closed, other_closed):
+        start, shift = start_shift
+        interval1 = Interval(start, start + shift, other_closed)
+        interval2 = Interval(start + shift, start + 2 * shift, closed)
+
+        # overlap if shared endpoint is closed for both (overlap at a point)
+        result = interval1.overlaps(interval2)
+        expected = interval1.closed_right and interval2.closed_left
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "other",
+        [10, True, "foo", Timedelta("1 day"), Timestamp("2018-01-01")],
+        ids=lambda x: type(x).__name__,
+    )
+    def test_overlaps_invalid_type(self, other):
+        interval = Interval(0, 1)
+        msg = f"`other` must be an Interval, got {type(other).__name__}"
+        with pytest.raises(TypeError, match=msg):
+            interval.overlaps(other)
+
+
+class TestContains:
+    def test_contains_interval(self, inclusive_endpoints_fixture):
+        interval1 = Interval(0, 1, "both")
+        interval2 = Interval(0, 1, inclusive_endpoints_fixture)
+        assert interval1 in interval1
+        assert interval2 in interval2
+        assert interval2 in interval1
+        assert interval1 not in interval2 or inclusive_endpoints_fixture == "both"
+
+    def test_contains_infinite_length(self):
+        interval1 = Interval(0, 1, "both")
+        interval2 = Interval(float("-inf"), float("inf"), "neither")
+        assert interval1 in interval2
+        assert interval2 not in interval1
+
+    def test_contains_zero_length(self):
+        interval1 = Interval(0, 1, "both")
+        interval2 = Interval(-1, -1, "both")
+        interval3 = Interval(0.5, 0.5, "both")
+        assert interval2 not in interval1
+        assert interval3 in interval1
+        assert interval2 not in interval3 and interval3 not in interval2
+        assert interval1 not in interval2 and interval1 not in interval3
+
+    @pytest.mark.parametrize(
+        "type1",
+        [
+            (0, 1),
+            (Timestamp(2000, 1, 1, 0), Timestamp(2000, 1, 1, 1)),
+            (Timedelta("0h"), Timedelta("1h")),
+        ],
+    )
+    @pytest.mark.parametrize(
+        "type2",
+        [
+            (0, 1),
+            (Timestamp(2000, 1, 1, 0), Timestamp(2000, 1, 1, 1)),
+            (Timedelta("0h"), Timedelta("1h")),
+        ],
+    )
+    def test_contains_mixed_types(self, type1, type2):
+        interval1 = Interval(*type1)
+        interval2 = Interval(*type2)
+        if type1 == type2:
+            assert interval1 in interval2
+        else:
+            msg = "^'<=' not supported between instances of"
+            with pytest.raises(TypeError, match=msg):
+                interval1 in interval2

videochat2/lib/python3.10/site-packages/pandas/tests/scalar/period/test_asfreq.py

@@ -0,0 +1,801 @@
+import pytest
+
+from pandas._libs.tslibs.dtypes import _period_code_map
+from pandas._libs.tslibs.period import INVALID_FREQ_ERR_MSG
+from pandas.errors import OutOfBoundsDatetime
+
+from pandas import (
+    Period,
+    Timestamp,
+    offsets,
+)
+
+
+class TestFreqConversion:
+    """Test frequency conversion of date objects"""
+
+    @pytest.mark.parametrize("freq", ["A", "Q", "M", "W", "B", "D"])
+    def test_asfreq_near_zero(self, freq):
+        # GH#19643, GH#19650
+        per = Period("0001-01-01", freq=freq)
+        tup1 = (per.year, per.hour, per.day)
+
+        prev = per - 1
+        assert prev.ordinal == per.ordinal - 1
+        tup2 = (prev.year, prev.month, prev.day)
+        assert tup2 < tup1
+
+    def test_asfreq_near_zero_weekly(self):
+        # GH#19834
+        per1 = Period("0001-01-01", "D") + 6
+        per2 = Period("0001-01-01", "D") - 6
+        week1 = per1.asfreq("W")
+        week2 = per2.asfreq("W")
+        assert week1 != week2
+        assert week1.asfreq("D", "E") >= per1
+        assert week2.asfreq("D", "S") <= per2
+
+    def test_to_timestamp_out_of_bounds(self):
+        # GH#19643, used to incorrectly give Timestamp in 1754
+        per = Period("0001-01-01", freq="B")
+        msg = "Out of bounds nanosecond timestamp"
+        with pytest.raises(OutOfBoundsDatetime, match=msg):
+            per.to_timestamp()
+
+    def test_asfreq_corner(self):
+        val = Period(freq="A", year=2007)
+        result1 = val.asfreq("5t")
+        result2 = val.asfreq("t")
+        expected = Period("2007-12-31 23:59", freq="t")
+        assert result1.ordinal == expected.ordinal
+        assert result1.freqstr == "5T"
+        assert result2.ordinal == expected.ordinal
+        assert result2.freqstr == "T"
+
+    def test_conv_annual(self):
+        # frequency conversion tests: from Annual Frequency
+
+        ival_A = Period(freq="A", year=2007)
+
+        ival_AJAN = Period(freq="A-JAN", year=2007)
+        ival_AJUN = Period(freq="A-JUN", year=2007)
+        ival_ANOV = Period(freq="A-NOV", year=2007)
+
+        ival_A_to_Q_start = Period(freq="Q", year=2007, quarter=1)
+        ival_A_to_Q_end = Period(freq="Q", year=2007, quarter=4)
+        ival_A_to_M_start = Period(freq="M", year=2007, month=1)
+        ival_A_to_M_end = Period(freq="M", year=2007, month=12)
+        ival_A_to_W_start = Period(freq="W", year=2007, month=1, day=1)
+        ival_A_to_W_end = Period(freq="W", year=2007, month=12, day=31)
+        ival_A_to_B_start = Period(freq="B", year=2007, month=1, day=1)
+        ival_A_to_B_end = Period(freq="B", year=2007, month=12, day=31)
+        ival_A_to_D_start = Period(freq="D", year=2007, month=1, day=1)
+        ival_A_to_D_end = Period(freq="D", year=2007, month=12, day=31)
+        ival_A_to_H_start = Period(freq="H", year=2007, month=1, day=1, hour=0)
+        ival_A_to_H_end = Period(freq="H", year=2007, month=12, day=31, hour=23)
+        ival_A_to_T_start = Period(
+            freq="Min", year=2007, month=1, day=1, hour=0, minute=0
+        )
+        ival_A_to_T_end = Period(
+            freq="Min", year=2007, month=12, day=31, hour=23, minute=59
+        )
+        ival_A_to_S_start = Period(
+            freq="S", year=2007, month=1, day=1, hour=0, minute=0, second=0
+        )
+        ival_A_to_S_end = Period(
+            freq="S", year=2007, month=12, day=31, hour=23, minute=59, second=59
+        )
+
+        ival_AJAN_to_D_end = Period(freq="D", year=2007, month=1, day=31)
+        ival_AJAN_to_D_start = Period(freq="D", year=2006, month=2, day=1)
+        ival_AJUN_to_D_end = Period(freq="D", year=2007, month=6, day=30)
+        ival_AJUN_to_D_start = Period(freq="D", year=2006, month=7, day=1)
+        ival_ANOV_to_D_end = Period(freq="D", year=2007, month=11, day=30)
+        ival_ANOV_to_D_start = Period(freq="D", year=2006, month=12, day=1)
+
+        assert ival_A.asfreq("Q", "S") == ival_A_to_Q_start
+        assert ival_A.asfreq("Q", "e") == ival_A_to_Q_end
+        assert ival_A.asfreq("M", "s") == ival_A_to_M_start
+        assert ival_A.asfreq("M", "E") == ival_A_to_M_end
+        assert ival_A.asfreq("W", "S") == ival_A_to_W_start
+        assert ival_A.asfreq("W", "E") == ival_A_to_W_end
+        assert ival_A.asfreq("B", "S") == ival_A_to_B_start
+        assert ival_A.asfreq("B", "E") == ival_A_to_B_end
+        assert ival_A.asfreq("D", "S") == ival_A_to_D_start
+        assert ival_A.asfreq("D", "E") == ival_A_to_D_end
+        assert ival_A.asfreq("H", "S") == ival_A_to_H_start
+        assert ival_A.asfreq("H", "E") == ival_A_to_H_end
+        assert ival_A.asfreq("min", "S") == ival_A_to_T_start
+        assert ival_A.asfreq("min", "E") == ival_A_to_T_end
+        assert ival_A.asfreq("T", "S") == ival_A_to_T_start
+        assert ival_A.asfreq("T", "E") == ival_A_to_T_end
+        assert ival_A.asfreq("S", "S") == ival_A_to_S_start
+        assert ival_A.asfreq("S", "E") == ival_A_to_S_end
+
+        assert ival_AJAN.asfreq("D", "S") == ival_AJAN_to_D_start
+        assert ival_AJAN.asfreq("D", "E") == ival_AJAN_to_D_end
+
+        assert ival_AJUN.asfreq("D", "S") == ival_AJUN_to_D_start
+        assert ival_AJUN.asfreq("D", "E") == ival_AJUN_to_D_end
+
+        assert ival_ANOV.asfreq("D", "S") == ival_ANOV_to_D_start
+        assert ival_ANOV.asfreq("D", "E") == ival_ANOV_to_D_end
+
+        assert ival_A.asfreq("A") == ival_A
+
+    def test_conv_quarterly(self):
+        # frequency conversion tests: from Quarterly Frequency
+
+        ival_Q = Period(freq="Q", year=2007, quarter=1)
+        ival_Q_end_of_year = Period(freq="Q", year=2007, quarter=4)
+
+        ival_QEJAN = Period(freq="Q-JAN", year=2007, quarter=1)
+        ival_QEJUN = Period(freq="Q-JUN", year=2007, quarter=1)
+
+        ival_Q_to_A = Period(freq="A", year=2007)
+        ival_Q_to_M_start = Period(freq="M", year=2007, month=1)
+        ival_Q_to_M_end = Period(freq="M", year=2007, month=3)
+        ival_Q_to_W_start = Period(freq="W", year=2007, month=1, day=1)
+        ival_Q_to_W_end = Period(freq="W", year=2007, month=3, day=31)
+        ival_Q_to_B_start = Period(freq="B", year=2007, month=1, day=1)
+        ival_Q_to_B_end = Period(freq="B", year=2007, month=3, day=30)
+        ival_Q_to_D_start = Period(freq="D", year=2007, month=1, day=1)
+        ival_Q_to_D_end = Period(freq="D", year=2007, month=3, day=31)
+        ival_Q_to_H_start = Period(freq="H", year=2007, month=1, day=1, hour=0)
+        ival_Q_to_H_end = Period(freq="H", year=2007, month=3, day=31, hour=23)
+        ival_Q_to_T_start = Period(
+            freq="Min", year=2007, month=1, day=1, hour=0, minute=0
+        )
+        ival_Q_to_T_end = Period(
+            freq="Min", year=2007, month=3, day=31, hour=23, minute=59
+        )
+        ival_Q_to_S_start = Period(
+            freq="S", year=2007, month=1, day=1, hour=0, minute=0, second=0
+        )
+        ival_Q_to_S_end = Period(
+            freq="S", year=2007, month=3, day=31, hour=23, minute=59, second=59
+        )
+
+        ival_QEJAN_to_D_start = Period(freq="D", year=2006, month=2, day=1)
+        ival_QEJAN_to_D_end = Period(freq="D", year=2006, month=4, day=30)
+
+        ival_QEJUN_to_D_start = Period(freq="D", year=2006, month=7, day=1)
+        ival_QEJUN_to_D_end = Period(freq="D", year=2006, month=9, day=30)
+
+        assert ival_Q.asfreq("A") == ival_Q_to_A
+        assert ival_Q_end_of_year.asfreq("A") == ival_Q_to_A
+
+        assert ival_Q.asfreq("M", "S") == ival_Q_to_M_start
+        assert ival_Q.asfreq("M", "E") == ival_Q_to_M_end
+        assert ival_Q.asfreq("W", "S") == ival_Q_to_W_start
+        assert ival_Q.asfreq("W", "E") == ival_Q_to_W_end
+        assert ival_Q.asfreq("B", "S") == ival_Q_to_B_start
+        assert ival_Q.asfreq("B", "E") == ival_Q_to_B_end
+        assert ival_Q.asfreq("D", "S") == ival_Q_to_D_start
+        assert ival_Q.asfreq("D", "E") == ival_Q_to_D_end
+        assert ival_Q.asfreq("H", "S") == ival_Q_to_H_start
+        assert ival_Q.asfreq("H", "E") == ival_Q_to_H_end
+        assert ival_Q.asfreq("Min", "S") == ival_Q_to_T_start
+        assert ival_Q.asfreq("Min", "E") == ival_Q_to_T_end
+        assert ival_Q.asfreq("S", "S") == ival_Q_to_S_start
+        assert ival_Q.asfreq("S", "E") == ival_Q_to_S_end
+
+        assert ival_QEJAN.asfreq("D", "S") == ival_QEJAN_to_D_start
+        assert ival_QEJAN.asfreq("D", "E") == ival_QEJAN_to_D_end
+        assert ival_QEJUN.asfreq("D", "S") == ival_QEJUN_to_D_start
+        assert ival_QEJUN.asfreq("D", "E") == ival_QEJUN_to_D_end
+
+        assert ival_Q.asfreq("Q") == ival_Q
+
+    def test_conv_monthly(self):
+        # frequency conversion tests: from Monthly Frequency
+
+        ival_M = Period(freq="M", year=2007, month=1)
+        ival_M_end_of_year = Period(freq="M", year=2007, month=12)
+        ival_M_end_of_quarter = Period(freq="M", year=2007, month=3)
+        ival_M_to_A = Period(freq="A", year=2007)
+        ival_M_to_Q = Period(freq="Q", year=2007, quarter=1)
+        ival_M_to_W_start = Period(freq="W", year=2007, month=1, day=1)
+        ival_M_to_W_end = Period(freq="W", year=2007, month=1, day=31)
+        ival_M_to_B_start = Period(freq="B", year=2007, month=1, day=1)
+        ival_M_to_B_end = Period(freq="B", year=2007, month=1, day=31)
+        ival_M_to_D_start = Period(freq="D", year=2007, month=1, day=1)
+        ival_M_to_D_end = Period(freq="D", year=2007, month=1, day=31)
+        ival_M_to_H_start = Period(freq="H", year=2007, month=1, day=1, hour=0)
+        ival_M_to_H_end = Period(freq="H", year=2007, month=1, day=31, hour=23)
+        ival_M_to_T_start = Period(
+            freq="Min", year=2007, month=1, day=1, hour=0, minute=0
+        )
+        ival_M_to_T_end = Period(
+            freq="Min", year=2007, month=1, day=31, hour=23, minute=59
+        )
+        ival_M_to_S_start = Period(
+            freq="S", year=2007, month=1, day=1, hour=0, minute=0, second=0
+        )
+        ival_M_to_S_end = Period(
+            freq="S", year=2007, month=1, day=31, hour=23, minute=59, second=59
+        )
+
+        assert ival_M.asfreq("A") == ival_M_to_A
+        assert ival_M_end_of_year.asfreq("A") == ival_M_to_A
+        assert ival_M.asfreq("Q") == ival_M_to_Q
+        assert ival_M_end_of_quarter.asfreq("Q") == ival_M_to_Q
+
+        assert ival_M.asfreq("W", "S") == ival_M_to_W_start
+        assert ival_M.asfreq("W", "E") == ival_M_to_W_end
+        assert ival_M.asfreq("B", "S") == ival_M_to_B_start
+        assert ival_M.asfreq("B", "E") == ival_M_to_B_end
+        assert ival_M.asfreq("D", "S") == ival_M_to_D_start
+        assert ival_M.asfreq("D", "E") == ival_M_to_D_end
+        assert ival_M.asfreq("H", "S") == ival_M_to_H_start
+        assert ival_M.asfreq("H", "E") == ival_M_to_H_end
+        assert ival_M.asfreq("Min", "S") == ival_M_to_T_start
+        assert ival_M.asfreq("Min", "E") == ival_M_to_T_end
+        assert ival_M.asfreq("S", "S") == ival_M_to_S_start
+        assert ival_M.asfreq("S", "E") == ival_M_to_S_end
+
+        assert ival_M.asfreq("M") == ival_M
+
+    def test_conv_weekly(self):
+        # frequency conversion tests: from Weekly Frequency
+        ival_W = Period(freq="W", year=2007, month=1, day=1)
+
+        ival_WSUN = Period(freq="W", year=2007, month=1, day=7)
+        ival_WSAT = Period(freq="W-SAT", year=2007, month=1, day=6)
+        ival_WFRI = Period(freq="W-FRI", year=2007, month=1, day=5)
+        ival_WTHU = Period(freq="W-THU", year=2007, month=1, day=4)
+        ival_WWED = Period(freq="W-WED", year=2007, month=1, day=3)
+        ival_WTUE = Period(freq="W-TUE", year=2007, month=1, day=2)
+        ival_WMON = Period(freq="W-MON", year=2007, month=1, day=1)
+
+        ival_WSUN_to_D_start = Period(freq="D", year=2007, month=1, day=1)
+        ival_WSUN_to_D_end = Period(freq="D", year=2007, month=1, day=7)
+        ival_WSAT_to_D_start = Period(freq="D", year=2006, month=12, day=31)
+        ival_WSAT_to_D_end = Period(freq="D", year=2007, month=1, day=6)
+        ival_WFRI_to_D_start = Period(freq="D", year=2006, month=12, day=30)
+        ival_WFRI_to_D_end = Period(freq="D", year=2007, month=1, day=5)
+        ival_WTHU_to_D_start = Period(freq="D", year=2006, month=12, day=29)
+        ival_WTHU_to_D_end = Period(freq="D", year=2007, month=1, day=4)
+        ival_WWED_to_D_start = Period(freq="D", year=2006, month=12, day=28)
+        ival_WWED_to_D_end = Period(freq="D", year=2007, month=1, day=3)
+        ival_WTUE_to_D_start = Period(freq="D", year=2006, month=12, day=27)
+        ival_WTUE_to_D_end = Period(freq="D", year=2007, month=1, day=2)
+        ival_WMON_to_D_start = Period(freq="D", year=2006, month=12, day=26)
+        ival_WMON_to_D_end = Period(freq="D", year=2007, month=1, day=1)
+
+        ival_W_end_of_year = Period(freq="W", year=2007, month=12, day=31)
+        ival_W_end_of_quarter = Period(freq="W", year=2007, month=3, day=31)
+        ival_W_end_of_month = Period(freq="W", year=2007, month=1, day=31)
+        ival_W_to_A = Period(freq="A", year=2007)
+        ival_W_to_Q = Period(freq="Q", year=2007, quarter=1)
+        ival_W_to_M = Period(freq="M", year=2007, month=1)
+
+        if Period(freq="D", year=2007, month=12, day=31).weekday == 6:
+            ival_W_to_A_end_of_year = Period(freq="A", year=2007)
+        else:
+            ival_W_to_A_end_of_year = Period(freq="A", year=2008)
+
+        if Period(freq="D", year=2007, month=3, day=31).weekday == 6:
+            ival_W_to_Q_end_of_quarter = Period(freq="Q", year=2007, quarter=1)
+        else:
+            ival_W_to_Q_end_of_quarter = Period(freq="Q", year=2007, quarter=2)
+
+        if Period(freq="D", year=2007, month=1, day=31).weekday == 6:
+            ival_W_to_M_end_of_month = Period(freq="M", year=2007, month=1)
+        else:
+            ival_W_to_M_end_of_month = Period(freq="M", year=2007, month=2)
+
+        ival_W_to_B_start = Period(freq="B", year=2007, month=1, day=1)
+        ival_W_to_B_end = Period(freq="B", year=2007, month=1, day=5)
+        ival_W_to_D_start = Period(freq="D", year=2007, month=1, day=1)
+        ival_W_to_D_end = Period(freq="D", year=2007, month=1, day=7)
+        ival_W_to_H_start = Period(freq="H", year=2007, month=1, day=1, hour=0)
+        ival_W_to_H_end = Period(freq="H", year=2007, month=1, day=7, hour=23)
+        ival_W_to_T_start = Period(
+            freq="Min", year=2007, month=1, day=1, hour=0, minute=0
+        )
+        ival_W_to_T_end = Period(
+            freq="Min", year=2007, month=1, day=7, hour=23, minute=59
+        )
+        ival_W_to_S_start = Period(
+            freq="S", year=2007, month=1, day=1, hour=0, minute=0, second=0
+        )
+        ival_W_to_S_end = Period(
+            freq="S", year=2007, month=1, day=7, hour=23, minute=59, second=59
+        )
+
+        assert ival_W.asfreq("A") == ival_W_to_A
+        assert ival_W_end_of_year.asfreq("A") == ival_W_to_A_end_of_year
+
+        assert ival_W.asfreq("Q") == ival_W_to_Q
+        assert ival_W_end_of_quarter.asfreq("Q") == ival_W_to_Q_end_of_quarter
+
+        assert ival_W.asfreq("M") == ival_W_to_M
+        assert ival_W_end_of_month.asfreq("M") == ival_W_to_M_end_of_month
+
+        assert ival_W.asfreq("B", "S") == ival_W_to_B_start
+        assert ival_W.asfreq("B", "E") == ival_W_to_B_end
+
+        assert ival_W.asfreq("D", "S") == ival_W_to_D_start
+        assert ival_W.asfreq("D", "E") == ival_W_to_D_end
+
+        assert ival_WSUN.asfreq("D", "S") == ival_WSUN_to_D_start
+        assert ival_WSUN.asfreq("D", "E") == ival_WSUN_to_D_end
+        assert ival_WSAT.asfreq("D", "S") == ival_WSAT_to_D_start
+        assert ival_WSAT.asfreq("D", "E") == ival_WSAT_to_D_end
+        assert ival_WFRI.asfreq("D", "S") == ival_WFRI_to_D_start
+        assert ival_WFRI.asfreq("D", "E") == ival_WFRI_to_D_end
+        assert ival_WTHU.asfreq("D", "S") == ival_WTHU_to_D_start
+        assert ival_WTHU.asfreq("D", "E") == ival_WTHU_to_D_end
+        assert ival_WWED.asfreq("D", "S") == ival_WWED_to_D_start
+        assert ival_WWED.asfreq("D", "E") == ival_WWED_to_D_end
+        assert ival_WTUE.asfreq("D", "S") == ival_WTUE_to_D_start
+        assert ival_WTUE.asfreq("D", "E") == ival_WTUE_to_D_end
+        assert ival_WMON.asfreq("D", "S") == ival_WMON_to_D_start
+        assert ival_WMON.asfreq("D", "E") == ival_WMON_to_D_end
+
+        assert ival_W.asfreq("H", "S") == ival_W_to_H_start
+        assert ival_W.asfreq("H", "E") == ival_W_to_H_end
+        assert ival_W.asfreq("Min", "S") == ival_W_to_T_start
+        assert ival_W.asfreq("Min", "E") == ival_W_to_T_end
+        assert ival_W.asfreq("S", "S") == ival_W_to_S_start
+        assert ival_W.asfreq("S", "E") == ival_W_to_S_end
+
+        assert ival_W.asfreq("W") == ival_W
+
+        msg = INVALID_FREQ_ERR_MSG
+        with pytest.raises(ValueError, match=msg):
+            ival_W.asfreq("WK")
+
+    def test_conv_weekly_legacy(self):
+        # frequency conversion tests: from Weekly Frequency
+        msg = INVALID_FREQ_ERR_MSG
+        with pytest.raises(ValueError, match=msg):
+            Period(freq="WK", year=2007, month=1, day=1)
+
+        with pytest.raises(ValueError, match=msg):
+            Period(freq="WK-SAT", year=2007, month=1, day=6)
+        with pytest.raises(ValueError, match=msg):
+            Period(freq="WK-FRI", year=2007, month=1, day=5)
+        with pytest.raises(ValueError, match=msg):
+            Period(freq="WK-THU", year=2007, month=1, day=4)
+        with pytest.raises(ValueError, match=msg):
+            Period(freq="WK-WED", year=2007, month=1, day=3)
+        with pytest.raises(ValueError, match=msg):
+            Period(freq="WK-TUE", year=2007, month=1, day=2)
+        with pytest.raises(ValueError, match=msg):
+            Period(freq="WK-MON", year=2007, month=1, day=1)
+
+    def test_conv_business(self):
+        # frequency conversion tests: from Business Frequency"
+
+        ival_B = Period(freq="B", year=2007, month=1, day=1)
+        ival_B_end_of_year = Period(freq="B", year=2007, month=12, day=31)
+        ival_B_end_of_quarter = Period(freq="B", year=2007, month=3, day=30)
+        ival_B_end_of_month = Period(freq="B", year=2007, month=1, day=31)
+        ival_B_end_of_week = Period(freq="B", year=2007, month=1, day=5)
+
+        ival_B_to_A = Period(freq="A", year=2007)
+        ival_B_to_Q = Period(freq="Q", year=2007, quarter=1)
+        ival_B_to_M = Period(freq="M", year=2007, month=1)
+        ival_B_to_W = Period(freq="W", year=2007, month=1, day=7)
+        ival_B_to_D = Period(freq="D", year=2007, month=1, day=1)
+        ival_B_to_H_start = Period(freq="H", year=2007, month=1, day=1, hour=0)
+        ival_B_to_H_end = Period(freq="H", year=2007, month=1, day=1, hour=23)
+        ival_B_to_T_start = Period(
+            freq="Min", year=2007, month=1, day=1, hour=0, minute=0
+        )
+        ival_B_to_T_end = Period(
+            freq="Min", year=2007, month=1, day=1, hour=23, minute=59
+        )
+        ival_B_to_S_start = Period(
+            freq="S", year=2007, month=1, day=1, hour=0, minute=0, second=0
+        )
+        ival_B_to_S_end = Period(
+            freq="S", year=2007, month=1, day=1, hour=23, minute=59, second=59
+        )
+
+        assert ival_B.asfreq("A") == ival_B_to_A
+        assert ival_B_end_of_year.asfreq("A") == ival_B_to_A
+        assert ival_B.asfreq("Q") == ival_B_to_Q
+        assert ival_B_end_of_quarter.asfreq("Q") == ival_B_to_Q
+        assert ival_B.asfreq("M") == ival_B_to_M
+        assert ival_B_end_of_month.asfreq("M") == ival_B_to_M
+        assert ival_B.asfreq("W") == ival_B_to_W
+        assert ival_B_end_of_week.asfreq("W") == ival_B_to_W
+
+        assert ival_B.asfreq("D") == ival_B_to_D
+
+        assert ival_B.asfreq("H", "S") == ival_B_to_H_start
+        assert ival_B.asfreq("H", "E") == ival_B_to_H_end
+        assert ival_B.asfreq("Min", "S") == ival_B_to_T_start
+        assert ival_B.asfreq("Min", "E") == ival_B_to_T_end
+        assert ival_B.asfreq("S", "S") == ival_B_to_S_start
+        assert ival_B.asfreq("S", "E") == ival_B_to_S_end
+
+        assert ival_B.asfreq("B") == ival_B
+
+    def test_conv_daily(self):
+        # frequency conversion tests: from Business Frequency"
+
+        ival_D = Period(freq="D", year=2007, month=1, day=1)
+        ival_D_end_of_year = Period(freq="D", year=2007, month=12, day=31)
+        ival_D_end_of_quarter = Period(freq="D", year=2007, month=3, day=31)
+        ival_D_end_of_month = Period(freq="D", year=2007, month=1, day=31)
+        ival_D_end_of_week = Period(freq="D", year=2007, month=1, day=7)
+
+        ival_D_friday = Period(freq="D", year=2007, month=1, day=5)
+        ival_D_saturday = Period(freq="D", year=2007, month=1, day=6)
+        ival_D_sunday = Period(freq="D", year=2007, month=1, day=7)
+
+        ival_B_friday = Period(freq="B", year=2007, month=1, day=5)
+        ival_B_monday = Period(freq="B", year=2007, month=1, day=8)
+
+        ival_D_to_A = Period(freq="A", year=2007)
+
+        ival_Deoq_to_AJAN = Period(freq="A-JAN", year=2008)
+        ival_Deoq_to_AJUN = Period(freq="A-JUN", year=2007)
+        ival_Deoq_to_ADEC = Period(freq="A-DEC", year=2007)
+
+        ival_D_to_QEJAN = Period(freq="Q-JAN", year=2007, quarter=4)
+        ival_D_to_QEJUN = Period(freq="Q-JUN", year=2007, quarter=3)
+        ival_D_to_QEDEC = Period(freq="Q-DEC", year=2007, quarter=1)
+
+        ival_D_to_M = Period(freq="M", year=2007, month=1)
+        ival_D_to_W = Period(freq="W", year=2007, month=1, day=7)
+
+        ival_D_to_H_start = Period(freq="H", year=2007, month=1, day=1, hour=0)
+        ival_D_to_H_end = Period(freq="H", year=2007, month=1, day=1, hour=23)
+        ival_D_to_T_start = Period(
+            freq="Min", year=2007, month=1, day=1, hour=0, minute=0
+        )
+        ival_D_to_T_end = Period(
+            freq="Min", year=2007, month=1, day=1, hour=23, minute=59
+        )
+        ival_D_to_S_start = Period(
+            freq="S", year=2007, month=1, day=1, hour=0, minute=0, second=0
+        )
+        ival_D_to_S_end = Period(
+            freq="S", year=2007, month=1, day=1, hour=23, minute=59, second=59
+        )
+
+        assert ival_D.asfreq("A") == ival_D_to_A
+
+        assert ival_D_end_of_quarter.asfreq("A-JAN") == ival_Deoq_to_AJAN
+        assert ival_D_end_of_quarter.asfreq("A-JUN") == ival_Deoq_to_AJUN
+        assert ival_D_end_of_quarter.asfreq("A-DEC") == ival_Deoq_to_ADEC
+
+        assert ival_D_end_of_year.asfreq("A") == ival_D_to_A
+        assert ival_D_end_of_quarter.asfreq("Q") == ival_D_to_QEDEC
+        assert ival_D.asfreq("Q-JAN") == ival_D_to_QEJAN
+        assert ival_D.asfreq("Q-JUN") == ival_D_to_QEJUN
+        assert ival_D.asfreq("Q-DEC") == ival_D_to_QEDEC
+        assert ival_D.asfreq("M") == ival_D_to_M
+        assert ival_D_end_of_month.asfreq("M") == ival_D_to_M
+        assert ival_D.asfreq("W") == ival_D_to_W
+        assert ival_D_end_of_week.asfreq("W") == ival_D_to_W
+
+        assert ival_D_friday.asfreq("B") == ival_B_friday
+        assert ival_D_saturday.asfreq("B", "S") == ival_B_friday
+        assert ival_D_saturday.asfreq("B", "E") == ival_B_monday
+        assert ival_D_sunday.asfreq("B", "S") == ival_B_friday
+        assert ival_D_sunday.asfreq("B", "E") == ival_B_monday
+
+        assert ival_D.asfreq("H", "S") == ival_D_to_H_start
+        assert ival_D.asfreq("H", "E") == ival_D_to_H_end
+        assert ival_D.asfreq("Min", "S") == ival_D_to_T_start
+        assert ival_D.asfreq("Min", "E") == ival_D_to_T_end
+        assert ival_D.asfreq("S", "S") == ival_D_to_S_start
+        assert ival_D.asfreq("S", "E") == ival_D_to_S_end
+
+        assert ival_D.asfreq("D") == ival_D
+
+    def test_conv_hourly(self):
+        # frequency conversion tests: from Hourly Frequency"
+
+        ival_H = Period(freq="H", year=2007, month=1, day=1, hour=0)
+        ival_H_end_of_year = Period(freq="H", year=2007, month=12, day=31, hour=23)
+        ival_H_end_of_quarter = Period(freq="H", year=2007, month=3, day=31, hour=23)
+        ival_H_end_of_month = Period(freq="H", year=2007, month=1, day=31, hour=23)
+        ival_H_end_of_week = Period(freq="H", year=2007, month=1, day=7, hour=23)
+        ival_H_end_of_day = Period(freq="H", year=2007, month=1, day=1, hour=23)
+        ival_H_end_of_bus = Period(freq="H", year=2007, month=1, day=1, hour=23)
+
+        ival_H_to_A = Period(freq="A", year=2007)
+        ival_H_to_Q = Period(freq="Q", year=2007, quarter=1)
+        ival_H_to_M = Period(freq="M", year=2007, month=1)
+        ival_H_to_W = Period(freq="W", year=2007, month=1, day=7)
+        ival_H_to_D = Period(freq="D", year=2007, month=1, day=1)
+        ival_H_to_B = Period(freq="B", year=2007, month=1, day=1)
+
+        ival_H_to_T_start = Period(
+            freq="Min", year=2007, month=1, day=1, hour=0, minute=0
+        )
+        ival_H_to_T_end = Period(
+            freq="Min", year=2007, month=1, day=1, hour=0, minute=59
+        )
+        ival_H_to_S_start = Period(
+            freq="S", year=2007, month=1, day=1, hour=0, minute=0, second=0
+        )
+        ival_H_to_S_end = Period(
+            freq="S", year=2007, month=1, day=1, hour=0, minute=59, second=59
+        )
+
+        assert ival_H.asfreq("A") == ival_H_to_A
+        assert ival_H_end_of_year.asfreq("A") == ival_H_to_A
+        assert ival_H.asfreq("Q") == ival_H_to_Q
+        assert ival_H_end_of_quarter.asfreq("Q") == ival_H_to_Q
+        assert ival_H.asfreq("M") == ival_H_to_M
+        assert ival_H_end_of_month.asfreq("M") == ival_H_to_M
+        assert ival_H.asfreq("W") == ival_H_to_W
+        assert ival_H_end_of_week.asfreq("W") == ival_H_to_W
+        assert ival_H.asfreq("D") == ival_H_to_D
+        assert ival_H_end_of_day.asfreq("D") == ival_H_to_D
+        assert ival_H.asfreq("B") == ival_H_to_B
+        assert ival_H_end_of_bus.asfreq("B") == ival_H_to_B
+
+        assert ival_H.asfreq("Min", "S") == ival_H_to_T_start
+        assert ival_H.asfreq("Min", "E") == ival_H_to_T_end
+        assert ival_H.asfreq("S", "S") == ival_H_to_S_start
+        assert ival_H.asfreq("S", "E") == ival_H_to_S_end
+
+        assert ival_H.asfreq("H") == ival_H
+
+    def test_conv_minutely(self):
+        # frequency conversion tests: from Minutely Frequency"
+
+        ival_T = Period(freq="Min", year=2007, month=1, day=1, hour=0, minute=0)
+        ival_T_end_of_year = Period(
+            freq="Min", year=2007, month=12, day=31, hour=23, minute=59
+        )
+        ival_T_end_of_quarter = Period(
+            freq="Min", year=2007, month=3, day=31, hour=23, minute=59
+        )
+        ival_T_end_of_month = Period(
+            freq="Min", year=2007, month=1, day=31, hour=23, minute=59
+        )
+        ival_T_end_of_week = Period(
+            freq="Min", year=2007, month=1, day=7, hour=23, minute=59
+        )
+        ival_T_end_of_day = Period(
+            freq="Min", year=2007, month=1, day=1, hour=23, minute=59
+        )
+        ival_T_end_of_bus = Period(
+            freq="Min", year=2007, month=1, day=1, hour=23, minute=59
+        )
+        ival_T_end_of_hour = Period(
+            freq="Min", year=2007, month=1, day=1, hour=0, minute=59
+        )
+
+        ival_T_to_A = Period(freq="A", year=2007)
+        ival_T_to_Q = Period(freq="Q", year=2007, quarter=1)
+        ival_T_to_M = Period(freq="M", year=2007, month=1)
+        ival_T_to_W = Period(freq="W", year=2007, month=1, day=7)
+        ival_T_to_D = Period(freq="D", year=2007, month=1, day=1)
+        ival_T_to_B = Period(freq="B", year=2007, month=1, day=1)
+        ival_T_to_H = Period(freq="H", year=2007, month=1, day=1, hour=0)
+
+        ival_T_to_S_start = Period(
+            freq="S", year=2007, month=1, day=1, hour=0, minute=0, second=0
+        )
+        ival_T_to_S_end = Period(
+            freq="S", year=2007, month=1, day=1, hour=0, minute=0, second=59
+        )
+
+        assert ival_T.asfreq("A") == ival_T_to_A
+        assert ival_T_end_of_year.asfreq("A") == ival_T_to_A
+        assert ival_T.asfreq("Q") == ival_T_to_Q
+        assert ival_T_end_of_quarter.asfreq("Q") == ival_T_to_Q
+        assert ival_T.asfreq("M") == ival_T_to_M
+        assert ival_T_end_of_month.asfreq("M") == ival_T_to_M
+        assert ival_T.asfreq("W") == ival_T_to_W
+        assert ival_T_end_of_week.asfreq("W") == ival_T_to_W
+        assert ival_T.asfreq("D") == ival_T_to_D
+        assert ival_T_end_of_day.asfreq("D") == ival_T_to_D
+        assert ival_T.asfreq("B") == ival_T_to_B
+        assert ival_T_end_of_bus.asfreq("B") == ival_T_to_B
+        assert ival_T.asfreq("H") == ival_T_to_H
+        assert ival_T_end_of_hour.asfreq("H") == ival_T_to_H
+
+        assert ival_T.asfreq("S", "S") == ival_T_to_S_start
+        assert ival_T.asfreq("S", "E") == ival_T_to_S_end
+
+        assert ival_T.asfreq("Min") == ival_T
+
+    def test_conv_secondly(self):
+        # frequency conversion tests: from Secondly Frequency"
+
+        ival_S = Period(freq="S", year=2007, month=1, day=1, hour=0, minute=0, second=0)
+        ival_S_end_of_year = Period(
+            freq="S", year=2007, month=12, day=31, hour=23, minute=59, second=59
+        )
+        ival_S_end_of_quarter = Period(
+            freq="S", year=2007, month=3, day=31, hour=23, minute=59, second=59
+        )
+        ival_S_end_of_month = Period(
+            freq="S", year=2007, month=1, day=31, hour=23, minute=59, second=59
+        )
+        ival_S_end_of_week = Period(
+            freq="S", year=2007, month=1, day=7, hour=23, minute=59, second=59
+        )
+        ival_S_end_of_day = Period(
+            freq="S", year=2007, month=1, day=1, hour=23, minute=59, second=59
+        )
+        ival_S_end_of_bus = Period(
+            freq="S", year=2007, month=1, day=1, hour=23, minute=59, second=59
+        )
+        ival_S_end_of_hour = Period(
+            freq="S", year=2007, month=1, day=1, hour=0, minute=59, second=59
+        )
+        ival_S_end_of_minute = Period(
+            freq="S", year=2007, month=1, day=1, hour=0, minute=0, second=59
+        )
+
+        ival_S_to_A = Period(freq="A", year=2007)
+        ival_S_to_Q = Period(freq="Q", year=2007, quarter=1)
+        ival_S_to_M = Period(freq="M", year=2007, month=1)
+        ival_S_to_W = Period(freq="W", year=2007, month=1, day=7)
+        ival_S_to_D = Period(freq="D", year=2007, month=1, day=1)
+        ival_S_to_B = Period(freq="B", year=2007, month=1, day=1)
+        ival_S_to_H = Period(freq="H", year=2007, month=1, day=1, hour=0)
+        ival_S_to_T = Period(freq="Min", year=2007, month=1, day=1, hour=0, minute=0)
+
+        assert ival_S.asfreq("A") == ival_S_to_A
+        assert ival_S_end_of_year.asfreq("A") == ival_S_to_A
+        assert ival_S.asfreq("Q") == ival_S_to_Q
+        assert ival_S_end_of_quarter.asfreq("Q") == ival_S_to_Q
+        assert ival_S.asfreq("M") == ival_S_to_M
+        assert ival_S_end_of_month.asfreq("M") == ival_S_to_M
+        assert ival_S.asfreq("W") == ival_S_to_W
+        assert ival_S_end_of_week.asfreq("W") == ival_S_to_W
+        assert ival_S.asfreq("D") == ival_S_to_D
+        assert ival_S_end_of_day.asfreq("D") == ival_S_to_D
+        assert ival_S.asfreq("B") == ival_S_to_B
+        assert ival_S_end_of_bus.asfreq("B") == ival_S_to_B
+        assert ival_S.asfreq("H") == ival_S_to_H
+        assert ival_S_end_of_hour.asfreq("H") == ival_S_to_H
+        assert ival_S.asfreq("Min") == ival_S_to_T
+        assert ival_S_end_of_minute.asfreq("Min") == ival_S_to_T
+
+        assert ival_S.asfreq("S") == ival_S
+
+    def test_conv_microsecond(self):
+        # GH#31475 Avoid floating point errors dropping the start_time to
+        #  before the beginning of the Period
+        per = Period("2020-01-30 15:57:27.576166", freq="U")
+        assert per.ordinal == 1580399847576166
+
+        start = per.start_time
+        expected = Timestamp("2020-01-30 15:57:27.576166")
+        assert start == expected
+        assert start._value == per.ordinal * 1000
+
+        per2 = Period("2300-01-01", "us")
+        msg = "2300-01-01"
+        with pytest.raises(OutOfBoundsDatetime, match=msg):
+            per2.start_time
+        with pytest.raises(OutOfBoundsDatetime, match=msg):
+            per2.end_time
+
+    def test_asfreq_mult(self):
+        # normal freq to mult freq
+        p = Period(freq="A", year=2007)
+        # ordinal will not change
+        for freq in ["3A", offsets.YearEnd(3)]:
+            result = p.asfreq(freq)
+            expected = Period("2007", freq="3A")
+
+            assert result == expected
+            assert result.ordinal == expected.ordinal
+            assert result.freq == expected.freq
+        # ordinal will not change
+        for freq in ["3A", offsets.YearEnd(3)]:
+            result = p.asfreq(freq, how="S")
+            expected = Period("2007", freq="3A")
+
+            assert result == expected
+            assert result.ordinal == expected.ordinal
+            assert result.freq == expected.freq
+
+        # mult freq to normal freq
+        p = Period(freq="3A", year=2007)
+        # ordinal will change because how=E is the default
+        for freq in ["A", offsets.YearEnd()]:
+            result = p.asfreq(freq)
+            expected = Period("2009", freq="A")
+
+            assert result == expected
+            assert result.ordinal == expected.ordinal
+            assert result.freq == expected.freq
+        # ordinal will not change
+        for freq in ["A", offsets.YearEnd()]:
+            result = p.asfreq(freq, how="S")
+            expected = Period("2007", freq="A")
+
+            assert result == expected
+            assert result.ordinal == expected.ordinal
+            assert result.freq == expected.freq
+
+        p = Period(freq="A", year=2007)
+        for freq in ["2M", offsets.MonthEnd(2)]:
+            result = p.asfreq(freq)
+            expected = Period("2007-12", freq="2M")
+
+            assert result == expected
+            assert result.ordinal == expected.ordinal
+            assert result.freq == expected.freq
+        for freq in ["2M", offsets.MonthEnd(2)]:
+            result = p.asfreq(freq, how="S")
+            expected = Period("2007-01", freq="2M")
+
+            assert result == expected
+            assert result.ordinal == expected.ordinal
+            assert result.freq == expected.freq
+
+        p = Period(freq="3A", year=2007)
+        for freq in ["2M", offsets.MonthEnd(2)]:
+            result = p.asfreq(freq)
+            expected = Period("2009-12", freq="2M")
+
+            assert result == expected
+            assert result.ordinal == expected.ordinal
+            assert result.freq == expected.freq
+        for freq in ["2M", offsets.MonthEnd(2)]:
+            result = p.asfreq(freq, how="S")
+            expected = Period("2007-01", freq="2M")
+
+            assert result == expected
+            assert result.ordinal == expected.ordinal
+            assert result.freq == expected.freq
+
+    def test_asfreq_combined(self):
+        # normal freq to combined freq
+        p = Period("2007", freq="H")
+
+        # ordinal will not change
+        expected = Period("2007", freq="25H")
+        for freq, how in zip(["1D1H", "1H1D"], ["E", "S"]):
+            result = p.asfreq(freq, how=how)
+            assert result == expected
+            assert result.ordinal == expected.ordinal
+            assert result.freq == expected.freq
+
+        # combined freq to normal freq
+        p1 = Period(freq="1D1H", year=2007)
+        p2 = Period(freq="1H1D", year=2007)
+
+        # ordinal will change because how=E is the default
+        result1 = p1.asfreq("H")
+        result2 = p2.asfreq("H")
+        expected = Period("2007-01-02", freq="H")
+        assert result1 == expected
+        assert result1.ordinal == expected.ordinal
+        assert result1.freq == expected.freq
+        assert result2 == expected
+        assert result2.ordinal == expected.ordinal
+        assert result2.freq == expected.freq
+
+        # ordinal will not change
+        result1 = p1.asfreq("H", how="S")
+        result2 = p2.asfreq("H", how="S")
+        expected = Period("2007-01-01", freq="H")
+        assert result1 == expected
+        assert result1.ordinal == expected.ordinal
+        assert result1.freq == expected.freq
+        assert result2 == expected
+        assert result2.ordinal == expected.ordinal
+        assert result2.freq == expected.freq
+
+    def test_asfreq_MS(self):
+        initial = Period("2013")
+
+        assert initial.asfreq(freq="M", how="S") == Period("2013-01", "M")
+
+        msg = INVALID_FREQ_ERR_MSG
+        with pytest.raises(ValueError, match=msg):
+            initial.asfreq(freq="MS", how="S")
+
+        with pytest.raises(ValueError, match=msg):
+            Period("2013-01", "MS")
+
+        assert _period_code_map.get("MS") is None

videochat2/lib/python3.10/site-packages/pandas/tests/scalar/period/test_period.py

@@ -0,0 +1,1570 @@
+from datetime import (
+    date,
+    datetime,
+    timedelta,
+)
+
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs import (
+    iNaT,
+    period as libperiod,
+)
+from pandas._libs.tslibs.ccalendar import (
+    DAYS,
+    MONTHS,
+)
+from pandas._libs.tslibs.np_datetime import OutOfBoundsDatetime
+from pandas._libs.tslibs.parsing import DateParseError
+from pandas._libs.tslibs.period import (
+    INVALID_FREQ_ERR_MSG,
+    IncompatibleFrequency,
+)
+
+import pandas as pd
+from pandas import (
+    NaT,
+    Period,
+    Timedelta,
+    Timestamp,
+    offsets,
+)
+import pandas._testing as tm
+
+
+class TestPeriodConstruction:
+    def test_from_td64nat_raises(self):
+        # GH#44507
+        td = NaT.to_numpy("m8[ns]")
+
+        msg = "Value must be Period, string, integer, or datetime"
+        with pytest.raises(ValueError, match=msg):
+            Period(td)
+
+        with pytest.raises(ValueError, match=msg):
+            Period(td, freq="D")
+
+    def test_construction(self):
+        i1 = Period("1/1/2005", freq="M")
+        i2 = Period("Jan 2005")
+
+        assert i1 == i2
+
+        i1 = Period("2005", freq="A")
+        i2 = Period("2005")
+        i3 = Period("2005", freq="a")
+
+        assert i1 == i2
+        assert i1 == i3
+
+        i4 = Period("2005", freq="M")
+        i5 = Period("2005", freq="m")
+
+        assert i1 != i4
+        assert i4 == i5
+
+        i1 = Period.now("Q")
+        i2 = Period(datetime.now(), freq="Q")
+        i3 = Period.now("q")
+
+        assert i1 == i2
+        assert i1 == i3
+
+        i1 = Period.now("D")
+        i2 = Period(datetime.now(), freq="D")
+        i3 = Period.now(offsets.Day())
+
+        assert i1 == i2
+        assert i1 == i3
+
+        i1 = Period("1982", freq="min")
+        i2 = Period("1982", freq="MIN")
+        assert i1 == i2
+
+        i1 = Period(year=2005, month=3, day=1, freq="D")
+        i2 = Period("3/1/2005", freq="D")
+        assert i1 == i2
+
+        i3 = Period(year=2005, month=3, day=1, freq="d")
+        assert i1 == i3
+
+        i1 = Period("2007-01-01 09:00:00.001")
+        expected = Period(datetime(2007, 1, 1, 9, 0, 0, 1000), freq="L")
+        assert i1 == expected
+
+        expected = Period("2007-01-01 09:00:00.001", freq="L")
+        assert i1 == expected
+
+        i1 = Period("2007-01-01 09:00:00.00101")
+        expected = Period(datetime(2007, 1, 1, 9, 0, 0, 1010), freq="U")
+        assert i1 == expected
+
+        expected = Period("2007-01-01 09:00:00.00101", freq="U")
+        assert i1 == expected
+
+        msg = "Must supply freq for ordinal value"
+        with pytest.raises(ValueError, match=msg):
+            Period(ordinal=200701)
+
+        msg = "Invalid frequency: X"
+        with pytest.raises(ValueError, match=msg):
+            Period("2007-1-1", freq="X")
+
+        # GH#34703 tuple freq disallowed
+        with pytest.raises(TypeError, match="pass as a string instead"):
+            Period("1982", freq=("Min", 1))
+
+    def test_construction_from_timestamp_nanos(self):
+        # GH#46811 don't drop nanos from Timestamp
+        ts = Timestamp("2022-04-20 09:23:24.123456789")
+        per = Period(ts, freq="ns")
+
+        # should losslessly round-trip, not lose the 789
+        rt = per.to_timestamp()
+        assert rt == ts
+
+        # same thing but from a datetime64 object
+        dt64 = ts.asm8
+        per2 = Period(dt64, freq="ns")
+        rt2 = per2.to_timestamp()
+        assert rt2.asm8 == dt64
+
+    def test_construction_bday(self):
+        # Biz day construction, roll forward if non-weekday
+        i1 = Period("3/10/12", freq="B")
+        i2 = Period("3/10/12", freq="D")
+        assert i1 == i2.asfreq("B")
+        i2 = Period("3/11/12", freq="D")
+        assert i1 == i2.asfreq("B")
+        i2 = Period("3/12/12", freq="D")
+        assert i1 == i2.asfreq("B")
+
+        i3 = Period("3/10/12", freq="b")
+        assert i1 == i3
+
+        i1 = Period(year=2012, month=3, day=10, freq="B")
+        i2 = Period("3/12/12", freq="B")
+        assert i1 == i2
+
+    def test_construction_quarter(self):
+        i1 = Period(year=2005, quarter=1, freq="Q")
+        i2 = Period("1/1/2005", freq="Q")
+        assert i1 == i2
+
+        i1 = Period(year=2005, quarter=3, freq="Q")
+        i2 = Period("9/1/2005", freq="Q")
+        assert i1 == i2
+
+        i1 = Period("2005Q1")
+        i2 = Period(year=2005, quarter=1, freq="Q")
+        i3 = Period("2005q1")
+        assert i1 == i2
+        assert i1 == i3
+
+        i1 = Period("05Q1")
+        assert i1 == i2
+        lower = Period("05q1")
+        assert i1 == lower
+
+        i1 = Period("1Q2005")
+        assert i1 == i2
+        lower = Period("1q2005")
+        assert i1 == lower
+
+        i1 = Period("1Q05")
+        assert i1 == i2
+        lower = Period("1q05")
+        assert i1 == lower
+
+        i1 = Period("4Q1984")
+        assert i1.year == 1984
+        lower = Period("4q1984")
+        assert i1 == lower
+
+    def test_construction_month(self):
+        expected = Period("2007-01", freq="M")
+        i1 = Period("200701", freq="M")
+        assert i1 == expected
+
+        i1 = Period("200701", freq="M")
+        assert i1 == expected
+
+        i1 = Period(200701, freq="M")
+        assert i1 == expected
+
+        i1 = Period(ordinal=200701, freq="M")
+        assert i1.year == 18695
+
+        i1 = Period(datetime(2007, 1, 1), freq="M")
+        i2 = Period("200701", freq="M")
+        assert i1 == i2
+
+        i1 = Period(date(2007, 1, 1), freq="M")
+        i2 = Period(datetime(2007, 1, 1), freq="M")
+        i3 = Period(np.datetime64("2007-01-01"), freq="M")
+        i4 = Period("2007-01-01 00:00:00", freq="M")
+        i5 = Period("2007-01-01 00:00:00.000", freq="M")
+        assert i1 == i2
+        assert i1 == i3
+        assert i1 == i4
+        assert i1 == i5
+
+    def test_period_constructor_offsets(self):
+        assert Period("1/1/2005", freq=offsets.MonthEnd()) == Period(
+            "1/1/2005", freq="M"
+        )
+        assert Period("2005", freq=offsets.YearEnd()) == Period("2005", freq="A")
+        assert Period("2005", freq=offsets.MonthEnd()) == Period("2005", freq="M")
+        assert Period("3/10/12", freq=offsets.BusinessDay()) == Period(
+            "3/10/12", freq="B"
+        )
+        assert Period("3/10/12", freq=offsets.Day()) == Period("3/10/12", freq="D")
+
+        assert Period(
+            year=2005, quarter=1, freq=offsets.QuarterEnd(startingMonth=12)
+        ) == Period(year=2005, quarter=1, freq="Q")
+        assert Period(
+            year=2005, quarter=2, freq=offsets.QuarterEnd(startingMonth=12)
+        ) == Period(year=2005, quarter=2, freq="Q")
+
+        assert Period(year=2005, month=3, day=1, freq=offsets.Day()) == Period(
+            year=2005, month=3, day=1, freq="D"
+        )
+        assert Period(year=2012, month=3, day=10, freq=offsets.BDay()) == Period(
+            year=2012, month=3, day=10, freq="B"
+        )
+
+        expected = Period("2005-03-01", freq="3D")
+        assert Period(year=2005, month=3, day=1, freq=offsets.Day(3)) == expected
+        assert Period(year=2005, month=3, day=1, freq="3D") == expected
+
+        assert Period(year=2012, month=3, day=10, freq=offsets.BDay(3)) == Period(
+            year=2012, month=3, day=10, freq="3B"
+        )
+
+        assert Period(200701, freq=offsets.MonthEnd()) == Period(200701, freq="M")
+
+        i1 = Period(ordinal=200701, freq=offsets.MonthEnd())
+        i2 = Period(ordinal=200701, freq="M")
+        assert i1 == i2
+        assert i1.year == 18695
+        assert i2.year == 18695
+
+        i1 = Period(datetime(2007, 1, 1), freq="M")
+        i2 = Period("200701", freq="M")
+        assert i1 == i2
+
+        i1 = Period(date(2007, 1, 1), freq="M")
+        i2 = Period(datetime(2007, 1, 1), freq="M")
+        i3 = Period(np.datetime64("2007-01-01"), freq="M")
+        i4 = Period("2007-01-01 00:00:00", freq="M")
+        i5 = Period("2007-01-01 00:00:00.000", freq="M")
+        assert i1 == i2
+        assert i1 == i3
+        assert i1 == i4
+        assert i1 == i5
+
+        i1 = Period("2007-01-01 09:00:00.001")
+        expected = Period(datetime(2007, 1, 1, 9, 0, 0, 1000), freq="L")
+        assert i1 == expected
+
+        expected = Period("2007-01-01 09:00:00.001", freq="L")
+        assert i1 == expected
+
+        i1 = Period("2007-01-01 09:00:00.00101")
+        expected = Period(datetime(2007, 1, 1, 9, 0, 0, 1010), freq="U")
+        assert i1 == expected
+
+        expected = Period("2007-01-01 09:00:00.00101", freq="U")
+        assert i1 == expected
+
+    def test_invalid_arguments(self):
+        msg = "Must supply freq for datetime value"
+        with pytest.raises(ValueError, match=msg):
+            Period(datetime.now())
+        with pytest.raises(ValueError, match=msg):
+            Period(datetime.now().date())
+
+        msg = "Value must be Period, string, integer, or datetime"
+        with pytest.raises(ValueError, match=msg):
+            Period(1.6, freq="D")
+        msg = "Ordinal must be an integer"
+        with pytest.raises(ValueError, match=msg):
+            Period(ordinal=1.6, freq="D")
+        msg = "Only value or ordinal but not both should be given but not both"
+        with pytest.raises(ValueError, match=msg):
+            Period(ordinal=2, value=1, freq="D")
+
+        msg = "If value is None, freq cannot be None"
+        with pytest.raises(ValueError, match=msg):
+            Period(month=1)
+
+        msg = '^Given date string "-2000" not likely a datetime$'
+        with pytest.raises(ValueError, match=msg):
+            Period("-2000", "A")
+        msg = "day is out of range for month"
+        with pytest.raises(DateParseError, match=msg):
+            Period("0", "A")
+        msg = "Unknown datetime string format, unable to parse"
+        with pytest.raises(DateParseError, match=msg):
+            Period("1/1/-2000", "A")
+
+    def test_constructor_corner(self):
+        expected = Period("2007-01", freq="2M")
+        assert Period(year=2007, month=1, freq="2M") == expected
+
+        assert Period(None) is NaT
+
+        p = Period("2007-01-01", freq="D")
+
+        result = Period(p, freq="A")
+        exp = Period("2007", freq="A")
+        assert result == exp
+
+    def test_constructor_infer_freq(self):
+        p = Period("2007-01-01")
+        assert p.freq == "D"
+
+        p = Period("2007-01-01 07")
+        assert p.freq == "H"
+
+        p = Period("2007-01-01 07:10")
+        assert p.freq == "T"
+
+        p = Period("2007-01-01 07:10:15")
+        assert p.freq == "S"
+
+        p = Period("2007-01-01 07:10:15.123")
+        assert p.freq == "L"
+
+        # We see that there are 6 digits after the decimal, so get microsecond
+        #  even though they are all zeros.
+        p = Period("2007-01-01 07:10:15.123000")
+        assert p.freq == "U"
+
+        p = Period("2007-01-01 07:10:15.123400")
+        assert p.freq == "U"
+
+    def test_multiples(self):
+        result1 = Period("1989", freq="2A")
+        result2 = Period("1989", freq="A")
+        assert result1.ordinal == result2.ordinal
+        assert result1.freqstr == "2A-DEC"
+        assert result2.freqstr == "A-DEC"
+        assert result1.freq == offsets.YearEnd(2)
+        assert result2.freq == offsets.YearEnd()
+
+        assert (result1 + 1).ordinal == result1.ordinal + 2
+        assert (1 + result1).ordinal == result1.ordinal + 2
+        assert (result1 - 1).ordinal == result2.ordinal - 2
+        assert (-1 + result1).ordinal == result2.ordinal - 2
+
+    @pytest.mark.parametrize("month", MONTHS)
+    def test_period_cons_quarterly(self, month):
+        # bugs in scikits.timeseries
+        freq = f"Q-{month}"
+        exp = Period("1989Q3", freq=freq)
+        assert "1989Q3" in str(exp)
+        stamp = exp.to_timestamp("D", how="end")
+        p = Period(stamp, freq=freq)
+        assert p == exp
+
+        stamp = exp.to_timestamp("3D", how="end")
+        p = Period(stamp, freq=freq)
+        assert p == exp
+
+    @pytest.mark.parametrize("month", MONTHS)
+    def test_period_cons_annual(self, month):
+        # bugs in scikits.timeseries
+        freq = f"A-{month}"
+        exp = Period("1989", freq=freq)
+        stamp = exp.to_timestamp("D", how="end") + timedelta(days=30)
+        p = Period(stamp, freq=freq)
+
+        assert p == exp + 1
+        assert isinstance(p, Period)
+
+    @pytest.mark.parametrize("day", DAYS)
+    @pytest.mark.parametrize("num", range(10, 17))
+    def test_period_cons_weekly(self, num, day):
+        daystr = f"2011-02-{num}"
+        freq = f"W-{day}"
+
+        result = Period(daystr, freq=freq)
+        expected = Period(daystr, freq="D").asfreq(freq)
+        assert result == expected
+        assert isinstance(result, Period)
+
+    def test_parse_week_str_roundstrip(self):
+        # GH#50803
+        per = Period("2017-01-23/2017-01-29")
+        assert per.freq.freqstr == "W-SUN"
+
+        per = Period("2017-01-24/2017-01-30")
+        assert per.freq.freqstr == "W-MON"
+
+        msg = "Could not parse as weekly-freq Period"
+        with pytest.raises(ValueError, match=msg):
+            # not 6 days apart
+            Period("2016-01-23/2017-01-29")
+
+    def test_period_from_ordinal(self):
+        p = Period("2011-01", freq="M")
+        res = Period._from_ordinal(p.ordinal, freq="M")
+        assert p == res
+        assert isinstance(res, Period)
+
+    @pytest.mark.parametrize("freq", ["A", "M", "D", "H"])
+    def test_construct_from_nat_string_and_freq(self, freq):
+        per = Period("NaT", freq=freq)
+        assert per is NaT
+
+        per = Period("NaT", freq="2" + freq)
+        assert per is NaT
+
+        per = Period("NaT", freq="3" + freq)
+        assert per is NaT
+
+    def test_period_cons_nat(self):
+        p = Period("nat", freq="W-SUN")
+        assert p is NaT
+
+        p = Period(iNaT, freq="D")
+        assert p is NaT
+
+        p = Period(iNaT, freq="3D")
+        assert p is NaT
+
+        p = Period(iNaT, freq="1D1H")
+        assert p is NaT
+
+        p = Period("NaT")
+        assert p is NaT
+
+        p = Period(iNaT)
+        assert p is NaT
+
+    def test_period_cons_mult(self):
+        p1 = Period("2011-01", freq="3M")
+        p2 = Period("2011-01", freq="M")
+        assert p1.ordinal == p2.ordinal
+
+        assert p1.freq == offsets.MonthEnd(3)
+        assert p1.freqstr == "3M"
+
+        assert p2.freq == offsets.MonthEnd()
+        assert p2.freqstr == "M"
+
+        result = p1 + 1
+        assert result.ordinal == (p2 + 3).ordinal
+
+        assert result.freq == p1.freq
+        assert result.freqstr == "3M"
+
+        result = p1 - 1
+        assert result.ordinal == (p2 - 3).ordinal
+        assert result.freq == p1.freq
+        assert result.freqstr == "3M"
+
+        msg = "Frequency must be positive, because it represents span: -3M"
+        with pytest.raises(ValueError, match=msg):
+            Period("2011-01", freq="-3M")
+
+        msg = "Frequency must be positive, because it represents span: 0M"
+        with pytest.raises(ValueError, match=msg):
+            Period("2011-01", freq="0M")
+
+    def test_period_cons_combined(self):
+        p = [
+            (
+                Period("2011-01", freq="1D1H"),
+                Period("2011-01", freq="1H1D"),
+                Period("2011-01", freq="H"),
+            ),
+            (
+                Period(ordinal=1, freq="1D1H"),
+                Period(ordinal=1, freq="1H1D"),
+                Period(ordinal=1, freq="H"),
+            ),
+        ]
+
+        for p1, p2, p3 in p:
+            assert p1.ordinal == p3.ordinal
+            assert p2.ordinal == p3.ordinal
+
+            assert p1.freq == offsets.Hour(25)
+            assert p1.freqstr == "25H"
+
+            assert p2.freq == offsets.Hour(25)
+            assert p2.freqstr == "25H"
+
+            assert p3.freq == offsets.Hour()
+            assert p3.freqstr == "H"
+
+            result = p1 + 1
+            assert result.ordinal == (p3 + 25).ordinal
+            assert result.freq == p1.freq
+            assert result.freqstr == "25H"
+
+            result = p2 + 1
+            assert result.ordinal == (p3 + 25).ordinal
+            assert result.freq == p2.freq
+            assert result.freqstr == "25H"
+
+            result = p1 - 1
+            assert result.ordinal == (p3 - 25).ordinal
+            assert result.freq == p1.freq
+            assert result.freqstr == "25H"
+
+            result = p2 - 1
+            assert result.ordinal == (p3 - 25).ordinal
+            assert result.freq == p2.freq
+            assert result.freqstr == "25H"
+
+        msg = "Frequency must be positive, because it represents span: -25H"
+        with pytest.raises(ValueError, match=msg):
+            Period("2011-01", freq="-1D1H")
+        with pytest.raises(ValueError, match=msg):
+            Period("2011-01", freq="-1H1D")
+        with pytest.raises(ValueError, match=msg):
+            Period(ordinal=1, freq="-1D1H")
+        with pytest.raises(ValueError, match=msg):
+            Period(ordinal=1, freq="-1H1D")
+
+        msg = "Frequency must be positive, because it represents span: 0D"
+        with pytest.raises(ValueError, match=msg):
+            Period("2011-01", freq="0D0H")
+        with pytest.raises(ValueError, match=msg):
+            Period(ordinal=1, freq="0D0H")
+
+        # You can only combine together day and intraday offsets
+        msg = "Invalid frequency: 1W1D"
+        with pytest.raises(ValueError, match=msg):
+            Period("2011-01", freq="1W1D")
+        msg = "Invalid frequency: 1D1W"
+        with pytest.raises(ValueError, match=msg):
+            Period("2011-01", freq="1D1W")
+
+    @pytest.mark.parametrize("day", ["1970/01/01 ", "2020-12-31 ", "1981/09/13 "])
+    @pytest.mark.parametrize("hour", ["00:00:00", "00:00:01", "23:59:59", "12:00:59"])
+    @pytest.mark.parametrize(
+        "sec_float, expected",
+        [
+            (".000000001", 1),
+            (".000000999", 999),
+            (".123456789", 789),
+            (".999999999", 999),
+            (".999999000", 0),
+            # Test femtoseconds, attoseconds, picoseconds are dropped like Timestamp
+            (".999999001123", 1),
+            (".999999001123456", 1),
+            (".999999001123456789", 1),
+        ],
+    )
+    def test_period_constructor_nanosecond(self, day, hour, sec_float, expected):
+        # GH 34621
+
+        assert Period(day + hour + sec_float).start_time.nanosecond == expected
+
+    @pytest.mark.parametrize("hour", range(24))
+    def test_period_large_ordinal(self, hour):
+        # Issue #36430
+        # Integer overflow for Period over the maximum timestamp
+        p = Period(ordinal=2562048 + hour, freq="1H")
+        assert p.hour == hour
+
+
+class TestPeriodMethods:
+    def test_round_trip(self):
+        p = Period("2000Q1")
+        new_p = tm.round_trip_pickle(p)
+        assert new_p == p
+
+    def test_hash(self):
+        assert hash(Period("2011-01", freq="M")) == hash(Period("2011-01", freq="M"))
+
+        assert hash(Period("2011-01-01", freq="D")) != hash(Period("2011-01", freq="M"))
+
+        assert hash(Period("2011-01", freq="3M")) != hash(Period("2011-01", freq="2M"))
+
+        assert hash(Period("2011-01", freq="M")) != hash(Period("2011-02", freq="M"))
+
+    # --------------------------------------------------------------
+    # to_timestamp
+
+    def test_to_timestamp_mult(self):
+        p = Period("2011-01", freq="M")
+        assert p.to_timestamp(how="S") == Timestamp("2011-01-01")
+        expected = Timestamp("2011-02-01") - Timedelta(1, "ns")
+        assert p.to_timestamp(how="E") == expected
+
+        p = Period("2011-01", freq="3M")
+        assert p.to_timestamp(how="S") == Timestamp("2011-01-01")
+        expected = Timestamp("2011-04-01") - Timedelta(1, "ns")
+        assert p.to_timestamp(how="E") == expected
+
+    def test_to_timestamp(self):
+        p = Period("1982", freq="A")
+        start_ts = p.to_timestamp(how="S")
+        aliases = ["s", "StarT", "BEGIn"]
+        for a in aliases:
+            assert start_ts == p.to_timestamp("D", how=a)
+            # freq with mult should not affect to the result
+            assert start_ts == p.to_timestamp("3D", how=a)
+
+        end_ts = p.to_timestamp(how="E")
+        aliases = ["e", "end", "FINIsH"]
+        for a in aliases:
+            assert end_ts == p.to_timestamp("D", how=a)
+            assert end_ts == p.to_timestamp("3D", how=a)
+
+        from_lst = ["A", "Q", "M", "W", "B", "D", "H", "Min", "S"]
+
+        def _ex(p):
+            if p.freq == "B":
+                return p.start_time + Timedelta(days=1, nanoseconds=-1)
+            return Timestamp((p + p.freq).start_time._value - 1)
+
+        for fcode in from_lst:
+            p = Period("1982", freq=fcode)
+            result = p.to_timestamp().to_period(fcode)
+            assert result == p
+
+            assert p.start_time == p.to_timestamp(how="S")
+
+            assert p.end_time == _ex(p)
+
+        # Frequency other than daily
+
+        p = Period("1985", freq="A")
+
+        result = p.to_timestamp("H", how="end")
+        expected = Timestamp(1986, 1, 1) - Timedelta(1, "ns")
+        assert result == expected
+        result = p.to_timestamp("3H", how="end")
+        assert result == expected
+
+        result = p.to_timestamp("T", how="end")
+        expected = Timestamp(1986, 1, 1) - Timedelta(1, "ns")
+        assert result == expected
+        result = p.to_timestamp("2T", how="end")
+        assert result == expected
+
+        result = p.to_timestamp(how="end")
+        expected = Timestamp(1986, 1, 1) - Timedelta(1, "ns")
+        assert result == expected
+
+        expected = datetime(1985, 1, 1)
+        result = p.to_timestamp("H", how="start")
+        assert result == expected
+        result = p.to_timestamp("T", how="start")
+        assert result == expected
+        result = p.to_timestamp("S", how="start")
+        assert result == expected
+        result = p.to_timestamp("3H", how="start")
+        assert result == expected
+        result = p.to_timestamp("5S", how="start")
+        assert result == expected
+
+    def test_to_timestamp_business_end(self):
+        per = Period("1990-01-05", "B")  # Friday
+        result = per.to_timestamp("B", how="E")
+
+        expected = Timestamp("1990-01-06") - Timedelta(nanoseconds=1)
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "ts, expected",
+        [
+            ("1970-01-01 00:00:00", 0),
+            ("1970-01-01 00:00:00.000001", 1),
+            ("1970-01-01 00:00:00.00001", 10),
+            ("1970-01-01 00:00:00.499", 499000),
+            ("1999-12-31 23:59:59.999", 999000),
+            ("1999-12-31 23:59:59.999999", 999999),
+            ("2050-12-31 23:59:59.5", 500000),
+            ("2050-12-31 23:59:59.500001", 500001),
+            ("2050-12-31 23:59:59.123456", 123456),
+        ],
+    )
+    @pytest.mark.parametrize("freq", [None, "us", "ns"])
+    def test_to_timestamp_microsecond(self, ts, expected, freq):
+        # GH 24444
+        result = Period(ts).to_timestamp(freq=freq).microsecond
+        assert result == expected
+
+    # --------------------------------------------------------------
+    # Rendering: __repr__, strftime, etc
+
+    def test_repr(self):
+        p = Period("Jan-2000")
+        assert "2000-01" in repr(p)
+
+        p = Period("2000-12-15")
+        assert "2000-12-15" in repr(p)
+
+    def test_repr_nat(self):
+        p = Period("nat", freq="M")
+        assert repr(NaT) in repr(p)
+
+    def test_millisecond_repr(self):
+        p = Period("2000-01-01 12:15:02.123")
+
+        assert repr(p) == "Period('2000-01-01 12:15:02.123', 'L')"
+
+    def test_microsecond_repr(self):
+        p = Period("2000-01-01 12:15:02.123567")
+
+        assert repr(p) == "Period('2000-01-01 12:15:02.123567', 'U')"
+
+    def test_strftime(self):
+        # GH#3363
+        p = Period("2000-1-1 12:34:12", freq="S")
+        res = p.strftime("%Y-%m-%d %H:%M:%S")
+        assert res == "2000-01-01 12:34:12"
+        assert isinstance(res, str)
+
+
+class TestPeriodProperties:
+    """Test properties such as year, month, weekday, etc...."""
+
+    @pytest.mark.parametrize("freq", ["A", "M", "D", "H"])
+    def test_is_leap_year(self, freq):
+        # GH 13727
+        p = Period("2000-01-01 00:00:00", freq=freq)
+        assert p.is_leap_year
+        assert isinstance(p.is_leap_year, bool)
+
+        p = Period("1999-01-01 00:00:00", freq=freq)
+        assert not p.is_leap_year
+
+        p = Period("2004-01-01 00:00:00", freq=freq)
+        assert p.is_leap_year
+
+        p = Period("2100-01-01 00:00:00", freq=freq)
+        assert not p.is_leap_year
+
+    def test_quarterly_negative_ordinals(self):
+        p = Period(ordinal=-1, freq="Q-DEC")
+        assert p.year == 1969
+        assert p.quarter == 4
+        assert isinstance(p, Period)
+
+        p = Period(ordinal=-2, freq="Q-DEC")
+        assert p.year == 1969
+        assert p.quarter == 3
+        assert isinstance(p, Period)
+
+        p = Period(ordinal=-2, freq="M")
+        assert p.year == 1969
+        assert p.month == 11
+        assert isinstance(p, Period)
+
+    def test_freq_str(self):
+        i1 = Period("1982", freq="Min")
+        assert i1.freq == offsets.Minute()
+        assert i1.freqstr == "T"
+
+    def test_period_deprecated_freq(self):
+        cases = {
+            "M": ["MTH", "MONTH", "MONTHLY", "Mth", "month", "monthly"],
+            "B": ["BUS", "BUSINESS", "BUSINESSLY", "WEEKDAY", "bus"],
+            "D": ["DAY", "DLY", "DAILY", "Day", "Dly", "Daily"],
+            "H": ["HR", "HOUR", "HRLY", "HOURLY", "hr", "Hour", "HRly"],
+            "T": ["minute", "MINUTE", "MINUTELY", "minutely"],
+            "S": ["sec", "SEC", "SECOND", "SECONDLY", "second"],
+            "L": ["MILLISECOND", "MILLISECONDLY", "millisecond"],
+            "U": ["MICROSECOND", "MICROSECONDLY", "microsecond"],
+            "N": ["NANOSECOND", "NANOSECONDLY", "nanosecond"],
+        }
+
+        msg = INVALID_FREQ_ERR_MSG
+        for exp, freqs in cases.items():
+            for freq in freqs:
+                with pytest.raises(ValueError, match=msg):
+                    Period("2016-03-01 09:00", freq=freq)
+                with pytest.raises(ValueError, match=msg):
+                    Period(ordinal=1, freq=freq)
+
+            # check supported freq-aliases still works
+            p1 = Period("2016-03-01 09:00", freq=exp)
+            p2 = Period(ordinal=1, freq=exp)
+            assert isinstance(p1, Period)
+            assert isinstance(p2, Period)
+
+    @staticmethod
+    def _period_constructor(bound, offset):
+        return Period(
+            year=bound.year,
+            month=bound.month,
+            day=bound.day,
+            hour=bound.hour,
+            minute=bound.minute,
+            second=bound.second + offset,
+            freq="us",
+        )
+
+    @pytest.mark.parametrize("bound, offset", [(Timestamp.min, -1), (Timestamp.max, 1)])
+    @pytest.mark.parametrize("period_property", ["start_time", "end_time"])
+    def test_outer_bounds_start_and_end_time(self, bound, offset, period_property):
+        # GH #13346
+        period = TestPeriodProperties._period_constructor(bound, offset)
+        with pytest.raises(OutOfBoundsDatetime, match="Out of bounds nanosecond"):
+            getattr(period, period_property)
+
+    @pytest.mark.parametrize("bound, offset", [(Timestamp.min, -1), (Timestamp.max, 1)])
+    @pytest.mark.parametrize("period_property", ["start_time", "end_time"])
+    def test_inner_bounds_start_and_end_time(self, bound, offset, period_property):
+        # GH #13346
+        period = TestPeriodProperties._period_constructor(bound, -offset)
+        expected = period.to_timestamp().round(freq="S")
+        assert getattr(period, period_property).round(freq="S") == expected
+        expected = (bound - offset * Timedelta(1, unit="S")).floor("S")
+        assert getattr(period, period_property).floor("S") == expected
+
+    def test_start_time(self):
+        freq_lst = ["A", "Q", "M", "D", "H", "T", "S"]
+        xp = datetime(2012, 1, 1)
+        for f in freq_lst:
+            p = Period("2012", freq=f)
+            assert p.start_time == xp
+        assert Period("2012", freq="B").start_time == datetime(2012, 1, 2)
+        assert Period("2012", freq="W").start_time == datetime(2011, 12, 26)
+
+    def test_end_time(self):
+        p = Period("2012", freq="A")
+
+        def _ex(*args):
+            return Timestamp(Timestamp(datetime(*args)).as_unit("ns")._value - 1)
+
+        xp = _ex(2013, 1, 1)
+        assert xp == p.end_time
+
+        p = Period("2012", freq="Q")
+        xp = _ex(2012, 4, 1)
+        assert xp == p.end_time
+
+        p = Period("2012", freq="M")
+        xp = _ex(2012, 2, 1)
+        assert xp == p.end_time
+
+        p = Period("2012", freq="D")
+        xp = _ex(2012, 1, 2)
+        assert xp == p.end_time
+
+        p = Period("2012", freq="H")
+        xp = _ex(2012, 1, 1, 1)
+        assert xp == p.end_time
+
+        p = Period("2012", freq="B")
+        xp = _ex(2012, 1, 3)
+        assert xp == p.end_time
+
+        p = Period("2012", freq="W")
+        xp = _ex(2012, 1, 2)
+        assert xp == p.end_time
+
+        # Test for GH 11738
+        p = Period("2012", freq="15D")
+        xp = _ex(2012, 1, 16)
+        assert xp == p.end_time
+
+        p = Period("2012", freq="1D1H")
+        xp = _ex(2012, 1, 2, 1)
+        assert xp == p.end_time
+
+        p = Period("2012", freq="1H1D")
+        xp = _ex(2012, 1, 2, 1)
+        assert xp == p.end_time
+
+    def test_end_time_business_friday(self):
+        # GH#34449
+        per = Period("1990-01-05", "B")
+        result = per.end_time
+
+        expected = Timestamp("1990-01-06") - Timedelta(nanoseconds=1)
+        assert result == expected
+
+    def test_anchor_week_end_time(self):
+        def _ex(*args):
+            return Timestamp(Timestamp(datetime(*args)).as_unit("ns")._value - 1)
+
+        p = Period("2013-1-1", "W-SAT")
+        xp = _ex(2013, 1, 6)
+        assert p.end_time == xp
+
+    def test_properties_annually(self):
+        # Test properties on Periods with annually frequency.
+        a_date = Period(freq="A", year=2007)
+        assert a_date.year == 2007
+
+    def test_properties_quarterly(self):
+        # Test properties on Periods with daily frequency.
+        qedec_date = Period(freq="Q-DEC", year=2007, quarter=1)
+        qejan_date = Period(freq="Q-JAN", year=2007, quarter=1)
+        qejun_date = Period(freq="Q-JUN", year=2007, quarter=1)
+        #
+        for x in range(3):
+            for qd in (qedec_date, qejan_date, qejun_date):
+                assert (qd + x).qyear == 2007
+                assert (qd + x).quarter == x + 1
+
+    def test_properties_monthly(self):
+        # Test properties on Periods with daily frequency.
+        m_date = Period(freq="M", year=2007, month=1)
+        for x in range(11):
+            m_ival_x = m_date + x
+            assert m_ival_x.year == 2007
+            if 1 <= x + 1 <= 3:
+                assert m_ival_x.quarter == 1
+            elif 4 <= x + 1 <= 6:
+                assert m_ival_x.quarter == 2
+            elif 7 <= x + 1 <= 9:
+                assert m_ival_x.quarter == 3
+            elif 10 <= x + 1 <= 12:
+                assert m_ival_x.quarter == 4
+            assert m_ival_x.month == x + 1
+
+    def test_properties_weekly(self):
+        # Test properties on Periods with daily frequency.
+        w_date = Period(freq="W", year=2007, month=1, day=7)
+        #
+        assert w_date.year == 2007
+        assert w_date.quarter == 1
+        assert w_date.month == 1
+        assert w_date.week == 1
+        assert (w_date - 1).week == 52
+        assert w_date.days_in_month == 31
+        assert Period(freq="W", year=2012, month=2, day=1).days_in_month == 29
+
+    def test_properties_weekly_legacy(self):
+        # Test properties on Periods with daily frequency.
+        w_date = Period(freq="W", year=2007, month=1, day=7)
+        assert w_date.year == 2007
+        assert w_date.quarter == 1
+        assert w_date.month == 1
+        assert w_date.week == 1
+        assert (w_date - 1).week == 52
+        assert w_date.days_in_month == 31
+
+        exp = Period(freq="W", year=2012, month=2, day=1)
+        assert exp.days_in_month == 29
+
+        msg = INVALID_FREQ_ERR_MSG
+        with pytest.raises(ValueError, match=msg):
+            Period(freq="WK", year=2007, month=1, day=7)
+
+    def test_properties_daily(self):
+        # Test properties on Periods with daily frequency.
+        b_date = Period(freq="B", year=2007, month=1, day=1)
+        #
+        assert b_date.year == 2007
+        assert b_date.quarter == 1
+        assert b_date.month == 1
+        assert b_date.day == 1
+        assert b_date.weekday == 0
+        assert b_date.dayofyear == 1
+        assert b_date.days_in_month == 31
+        assert Period(freq="B", year=2012, month=2, day=1).days_in_month == 29
+
+        d_date = Period(freq="D", year=2007, month=1, day=1)
+
+        assert d_date.year == 2007
+        assert d_date.quarter == 1
+        assert d_date.month == 1
+        assert d_date.day == 1
+        assert d_date.weekday == 0
+        assert d_date.dayofyear == 1
+        assert d_date.days_in_month == 31
+        assert Period(freq="D", year=2012, month=2, day=1).days_in_month == 29
+
+    def test_properties_hourly(self):
+        # Test properties on Periods with hourly frequency.
+        h_date1 = Period(freq="H", year=2007, month=1, day=1, hour=0)
+        h_date2 = Period(freq="2H", year=2007, month=1, day=1, hour=0)
+
+        for h_date in [h_date1, h_date2]:
+            assert h_date.year == 2007
+            assert h_date.quarter == 1
+            assert h_date.month == 1
+            assert h_date.day == 1
+            assert h_date.weekday == 0
+            assert h_date.dayofyear == 1
+            assert h_date.hour == 0
+            assert h_date.days_in_month == 31
+            assert (
+                Period(freq="H", year=2012, month=2, day=1, hour=0).days_in_month == 29
+            )
+
+    def test_properties_minutely(self):
+        # Test properties on Periods with minutely frequency.
+        t_date = Period(freq="Min", year=2007, month=1, day=1, hour=0, minute=0)
+        #
+        assert t_date.quarter == 1
+        assert t_date.month == 1
+        assert t_date.day == 1
+        assert t_date.weekday == 0
+        assert t_date.dayofyear == 1
+        assert t_date.hour == 0
+        assert t_date.minute == 0
+        assert t_date.days_in_month == 31
+        assert (
+            Period(freq="D", year=2012, month=2, day=1, hour=0, minute=0).days_in_month
+            == 29
+        )
+
+    def test_properties_secondly(self):
+        # Test properties on Periods with secondly frequency.
+        s_date = Period(
+            freq="Min", year=2007, month=1, day=1, hour=0, minute=0, second=0
+        )
+        #
+        assert s_date.year == 2007
+        assert s_date.quarter == 1
+        assert s_date.month == 1
+        assert s_date.day == 1
+        assert s_date.weekday == 0
+        assert s_date.dayofyear == 1
+        assert s_date.hour == 0
+        assert s_date.minute == 0
+        assert s_date.second == 0
+        assert s_date.days_in_month == 31
+        assert (
+            Period(
+                freq="Min", year=2012, month=2, day=1, hour=0, minute=0, second=0
+            ).days_in_month
+            == 29
+        )
+
+
+class TestPeriodField:
+    def test_get_period_field_array_raises_on_out_of_range(self):
+        msg = "Buffer dtype mismatch, expected 'const int64_t' but got 'double'"
+        with pytest.raises(ValueError, match=msg):
+            libperiod.get_period_field_arr(-1, np.empty(1), 0)
+
+
+class TestPeriodComparisons:
+    def test_comparison_same_period_different_object(self):
+        # Separate Period objects for the same period
+        left = Period("2000-01", "M")
+        right = Period("2000-01", "M")
+
+        assert left == right
+        assert left >= right
+        assert left <= right
+        assert not left < right
+        assert not left > right
+
+    def test_comparison_same_freq(self):
+        jan = Period("2000-01", "M")
+        feb = Period("2000-02", "M")
+
+        assert not jan == feb
+        assert jan != feb
+        assert jan < feb
+        assert jan <= feb
+        assert not jan > feb
+        assert not jan >= feb
+
+    def test_comparison_mismatched_freq(self):
+        jan = Period("2000-01", "M")
+        day = Period("2012-01-01", "D")
+
+        assert not jan == day
+        assert jan != day
+        msg = r"Input has different freq=D from Period\(freq=M\)"
+        with pytest.raises(IncompatibleFrequency, match=msg):
+            jan < day
+        with pytest.raises(IncompatibleFrequency, match=msg):
+            jan <= day
+        with pytest.raises(IncompatibleFrequency, match=msg):
+            jan > day
+        with pytest.raises(IncompatibleFrequency, match=msg):
+            jan >= day
+
+    def test_comparison_invalid_type(self):
+        jan = Period("2000-01", "M")
+
+        assert not jan == 1
+        assert jan != 1
+
+        int_or_per = "'(Period|int)'"
+        msg = f"not supported between instances of {int_or_per} and {int_or_per}"
+        for left, right in [(jan, 1), (1, jan)]:
+            with pytest.raises(TypeError, match=msg):
+                left > right
+            with pytest.raises(TypeError, match=msg):
+                left >= right
+            with pytest.raises(TypeError, match=msg):
+                left < right
+            with pytest.raises(TypeError, match=msg):
+                left <= right
+
+    def test_sort_periods(self):
+        jan = Period("2000-01", "M")
+        feb = Period("2000-02", "M")
+        mar = Period("2000-03", "M")
+        periods = [mar, jan, feb]
+        correctPeriods = [jan, feb, mar]
+        assert sorted(periods) == correctPeriods
+
+    def test_period_cmp_nat(self):
+        p = Period("2011-01-01", freq="D")
+
+        t = Timestamp("2011-01-01")
+        # confirm Period('NaT') work identical with Timestamp('NaT')
+        for left, right in [
+            (NaT, p),
+            (p, NaT),
+            (NaT, t),
+            (t, NaT),
+        ]:
+            assert not left < right
+            assert not left > right
+            assert not left == right
+            assert left != right
+            assert not left <= right
+            assert not left >= right
+
+    @pytest.mark.parametrize(
+        "zerodim_arr, expected",
+        ((np.array(0), False), (np.array(Period("2000-01", "M")), True)),
+    )
+    def test_comparison_numpy_zerodim_arr(self, zerodim_arr, expected):
+        p = Period("2000-01", "M")
+
+        assert (p == zerodim_arr) is expected
+        assert (zerodim_arr == p) is expected
+
+
+class TestArithmetic:
+    @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s", "m"])
+    def test_add_sub_td64_nat(self, unit):
+        # GH#47196
+        per = Period("2022-06-01", "D")
+        nat = np.timedelta64("NaT", unit)
+
+        assert per + nat is NaT
+        assert nat + per is NaT
+        assert per - nat is NaT
+
+        with pytest.raises(TypeError, match="unsupported operand"):
+            nat - per
+
+    def test_sub_delta(self):
+        left, right = Period("2011", freq="A"), Period("2007", freq="A")
+        result = left - right
+        assert result == 4 * right.freq
+
+        msg = r"Input has different freq=M from Period\(freq=A-DEC\)"
+        with pytest.raises(IncompatibleFrequency, match=msg):
+            left - Period("2007-01", freq="M")
+
+    def test_add_integer(self):
+        per1 = Period(freq="D", year=2008, month=1, day=1)
+        per2 = Period(freq="D", year=2008, month=1, day=2)
+        assert per1 + 1 == per2
+        assert 1 + per1 == per2
+
+    def test_add_sub_nat(self):
+        # GH#13071
+        p = Period("2011-01", freq="M")
+        assert p + NaT is NaT
+        assert NaT + p is NaT
+        assert p - NaT is NaT
+        assert NaT - p is NaT
+
+    def test_add_invalid(self):
+        # GH#4731
+        per1 = Period(freq="D", year=2008, month=1, day=1)
+        per2 = Period(freq="D", year=2008, month=1, day=2)
+
+        msg = "|".join(
+            [
+                r"unsupported operand type\(s\)",
+                "can only concatenate str",
+                "must be str, not Period",
+            ]
+        )
+        with pytest.raises(TypeError, match=msg):
+            per1 + "str"
+        with pytest.raises(TypeError, match=msg):
+            "str" + per1
+        with pytest.raises(TypeError, match=msg):
+            per1 + per2
+
+    boxes = [lambda x: x, lambda x: pd.Series([x]), lambda x: pd.Index([x])]
+    ids = ["identity", "Series", "Index"]
+
+    @pytest.mark.parametrize("lbox", boxes, ids=ids)
+    @pytest.mark.parametrize("rbox", boxes, ids=ids)
+    def test_add_timestamp_raises(self, rbox, lbox):
+        # GH#17983
+        ts = Timestamp("2017")
+        per = Period("2017", freq="M")
+
+        # We may get a different message depending on which class raises
+        # the error.
+        msg = "|".join(
+            [
+                "cannot add",
+                "unsupported operand",
+                "can only operate on a",
+                "incompatible type",
+                "ufunc add cannot use operands",
+            ]
+        )
+        with pytest.raises(TypeError, match=msg):
+            lbox(ts) + rbox(per)
+
+        with pytest.raises(TypeError, match=msg):
+            lbox(per) + rbox(ts)
+
+        with pytest.raises(TypeError, match=msg):
+            lbox(per) + rbox(per)
+
+    def test_sub(self):
+        per1 = Period("2011-01-01", freq="D")
+        per2 = Period("2011-01-15", freq="D")
+
+        off = per1.freq
+        assert per1 - per2 == -14 * off
+        assert per2 - per1 == 14 * off
+
+        msg = r"Input has different freq=M from Period\(freq=D\)"
+        with pytest.raises(IncompatibleFrequency, match=msg):
+            per1 - Period("2011-02", freq="M")
+
+    @pytest.mark.parametrize("n", [1, 2, 3, 4])
+    def test_sub_n_gt_1_ticks(self, tick_classes, n):
+        # GH 23878
+        p1 = Period("19910905", freq=tick_classes(n))
+        p2 = Period("19920406", freq=tick_classes(n))
+
+        expected = Period(str(p2), freq=p2.freq.base) - Period(
+            str(p1), freq=p1.freq.base
+        )
+
+        assert (p2 - p1) == expected
+
+    @pytest.mark.parametrize("normalize", [True, False])
+    @pytest.mark.parametrize("n", [1, 2, 3, 4])
+    @pytest.mark.parametrize(
+        "offset, kwd_name",
+        [
+            (offsets.YearEnd, "month"),
+            (offsets.QuarterEnd, "startingMonth"),
+            (offsets.MonthEnd, None),
+            (offsets.Week, "weekday"),
+        ],
+    )
+    def test_sub_n_gt_1_offsets(self, offset, kwd_name, n, normalize):
+        # GH 23878
+        kwds = {kwd_name: 3} if kwd_name is not None else {}
+        p1_d = "19910905"
+        p2_d = "19920406"
+        p1 = Period(p1_d, freq=offset(n, normalize, **kwds))
+        p2 = Period(p2_d, freq=offset(n, normalize, **kwds))
+
+        expected = Period(p2_d, freq=p2.freq.base) - Period(p1_d, freq=p1.freq.base)
+
+        assert (p2 - p1) == expected
+
+    def test_add_offset(self):
+        # freq is DateOffset
+        for freq in ["A", "2A", "3A"]:
+            p = Period("2011", freq=freq)
+            exp = Period("2013", freq=freq)
+            assert p + offsets.YearEnd(2) == exp
+            assert offsets.YearEnd(2) + p == exp
+
+            for o in [
+                offsets.YearBegin(2),
+                offsets.MonthBegin(1),
+                offsets.Minute(),
+                np.timedelta64(365, "D"),
+                timedelta(365),
+            ]:
+                msg = "Input has different freq|Input cannot be converted to Period"
+                with pytest.raises(IncompatibleFrequency, match=msg):
+                    p + o
+                with pytest.raises(IncompatibleFrequency, match=msg):
+                    o + p
+
+        for freq in ["M", "2M", "3M"]:
+            p = Period("2011-03", freq=freq)
+            exp = Period("2011-05", freq=freq)
+            assert p + offsets.MonthEnd(2) == exp
+            assert offsets.MonthEnd(2) + p == exp
+
+            exp = Period("2012-03", freq=freq)
+            assert p + offsets.MonthEnd(12) == exp
+            assert offsets.MonthEnd(12) + p == exp
+
+            msg = "|".join(
+                [
+                    "Input has different freq",
+                    "Input cannot be converted to Period",
+                ]
+            )
+
+            for o in [
+                offsets.YearBegin(2),
+                offsets.MonthBegin(1),
+                offsets.Minute(),
+                np.timedelta64(365, "D"),
+                timedelta(365),
+            ]:
+                with pytest.raises(IncompatibleFrequency, match=msg):
+                    p + o
+                with pytest.raises(IncompatibleFrequency, match=msg):
+                    o + p
+
+        # freq is Tick
+        for freq in ["D", "2D", "3D"]:
+            p = Period("2011-04-01", freq=freq)
+
+            exp = Period("2011-04-06", freq=freq)
+            assert p + offsets.Day(5) == exp
+            assert offsets.Day(5) + p == exp
+
+            exp = Period("2011-04-02", freq=freq)
+            assert p + offsets.Hour(24) == exp
+            assert offsets.Hour(24) + p == exp
+
+            exp = Period("2011-04-03", freq=freq)
+            assert p + np.timedelta64(2, "D") == exp
+            assert np.timedelta64(2, "D") + p == exp
+
+            exp = Period("2011-04-02", freq=freq)
+            assert p + np.timedelta64(3600 * 24, "s") == exp
+            assert np.timedelta64(3600 * 24, "s") + p == exp
+
+            exp = Period("2011-03-30", freq=freq)
+            assert p + timedelta(-2) == exp
+            assert timedelta(-2) + p == exp
+
+            exp = Period("2011-04-03", freq=freq)
+            assert p + timedelta(hours=48) == exp
+            assert timedelta(hours=48) + p == exp
+
+            msg = "|".join(
+                [
+                    "Input has different freq",
+                    "Input cannot be converted to Period",
+                ]
+            )
+
+            for o in [
+                offsets.YearBegin(2),
+                offsets.MonthBegin(1),
+                offsets.Minute(),
+                np.timedelta64(4, "h"),
+                timedelta(hours=23),
+            ]:
+                with pytest.raises(IncompatibleFrequency, match=msg):
+                    p + o
+                with pytest.raises(IncompatibleFrequency, match=msg):
+                    o + p
+
+        for freq in ["H", "2H", "3H"]:
+            p = Period("2011-04-01 09:00", freq=freq)
+
+            exp = Period("2011-04-03 09:00", freq=freq)
+            assert p + offsets.Day(2) == exp
+            assert offsets.Day(2) + p == exp
+
+            exp = Period("2011-04-01 12:00", freq=freq)
+            assert p + offsets.Hour(3) == exp
+            assert offsets.Hour(3) + p == exp
+
+            msg = "cannot use operands with types"
+            exp = Period("2011-04-01 12:00", freq=freq)
+            assert p + np.timedelta64(3, "h") == exp
+            assert np.timedelta64(3, "h") + p == exp
+
+            exp = Period("2011-04-01 10:00", freq=freq)
+            assert p + np.timedelta64(3600, "s") == exp
+            assert np.timedelta64(3600, "s") + p == exp
+
+            exp = Period("2011-04-01 11:00", freq=freq)
+            assert p + timedelta(minutes=120) == exp
+            assert timedelta(minutes=120) + p == exp
+
+            exp = Period("2011-04-05 12:00", freq=freq)
+            assert p + timedelta(days=4, minutes=180) == exp
+            assert timedelta(days=4, minutes=180) + p == exp
+
+            msg = "|".join(
+                [
+                    "Input has different freq",
+                    "Input cannot be converted to Period",
+                ]
+            )
+
+            for o in [
+                offsets.YearBegin(2),
+                offsets.MonthBegin(1),
+                offsets.Minute(),
+                np.timedelta64(3200, "s"),
+                timedelta(hours=23, minutes=30),
+            ]:
+                with pytest.raises(IncompatibleFrequency, match=msg):
+                    p + o
+                with pytest.raises(IncompatibleFrequency, match=msg):
+                    o + p
+
+    def test_sub_offset(self):
+        # freq is DateOffset
+        msg = "|".join(
+            [
+                "Input has different freq",
+                "Input cannot be converted to Period",
+            ]
+        )
+
+        for freq in ["A", "2A", "3A"]:
+            p = Period("2011", freq=freq)
+            assert p - offsets.YearEnd(2) == Period("2009", freq=freq)
+
+            for o in [
+                offsets.YearBegin(2),
+                offsets.MonthBegin(1),
+                offsets.Minute(),
+                np.timedelta64(365, "D"),
+                timedelta(365),
+            ]:
+                with pytest.raises(IncompatibleFrequency, match=msg):
+                    p - o
+
+        for freq in ["M", "2M", "3M"]:
+            p = Period("2011-03", freq=freq)
+            assert p - offsets.MonthEnd(2) == Period("2011-01", freq=freq)
+            assert p - offsets.MonthEnd(12) == Period("2010-03", freq=freq)
+
+            for o in [
+                offsets.YearBegin(2),
+                offsets.MonthBegin(1),
+                offsets.Minute(),
+                np.timedelta64(365, "D"),
+                timedelta(365),
+            ]:
+                with pytest.raises(IncompatibleFrequency, match=msg):
+                    p - o
+
+        # freq is Tick
+        for freq in ["D", "2D", "3D"]:
+            p = Period("2011-04-01", freq=freq)
+            assert p - offsets.Day(5) == Period("2011-03-27", freq=freq)
+            assert p - offsets.Hour(24) == Period("2011-03-31", freq=freq)
+            assert p - np.timedelta64(2, "D") == Period("2011-03-30", freq=freq)
+            assert p - np.timedelta64(3600 * 24, "s") == Period("2011-03-31", freq=freq)
+            assert p - timedelta(-2) == Period("2011-04-03", freq=freq)
+            assert p - timedelta(hours=48) == Period("2011-03-30", freq=freq)
+
+            for o in [
+                offsets.YearBegin(2),
+                offsets.MonthBegin(1),
+                offsets.Minute(),
+                np.timedelta64(4, "h"),
+                timedelta(hours=23),
+            ]:
+                with pytest.raises(IncompatibleFrequency, match=msg):
+                    p - o
+
+        for freq in ["H", "2H", "3H"]:
+            p = Period("2011-04-01 09:00", freq=freq)
+            assert p - offsets.Day(2) == Period("2011-03-30 09:00", freq=freq)
+            assert p - offsets.Hour(3) == Period("2011-04-01 06:00", freq=freq)
+            assert p - np.timedelta64(3, "h") == Period("2011-04-01 06:00", freq=freq)
+            assert p - np.timedelta64(3600, "s") == Period(
+                "2011-04-01 08:00", freq=freq
+            )
+            assert p - timedelta(minutes=120) == Period("2011-04-01 07:00", freq=freq)
+            assert p - timedelta(days=4, minutes=180) == Period(
+                "2011-03-28 06:00", freq=freq
+            )
+
+            for o in [
+                offsets.YearBegin(2),
+                offsets.MonthBegin(1),
+                offsets.Minute(),
+                np.timedelta64(3200, "s"),
+                timedelta(hours=23, minutes=30),
+            ]:
+                with pytest.raises(IncompatibleFrequency, match=msg):
+                    p - o
+
+    @pytest.mark.parametrize("freq", ["M", "2M", "3M"])
+    def test_period_addsub_nat(self, freq):
+        per = Period("2011-01", freq=freq)
+
+        # For subtraction, NaT is treated as another Period object
+        assert NaT - per is NaT
+        assert per - NaT is NaT
+
+        # For addition, NaT is treated as offset-like
+        assert NaT + per is NaT
+        assert per + NaT is NaT
+
+    def test_period_ops_offset(self):
+        p = Period("2011-04-01", freq="D")
+        result = p + offsets.Day()
+        exp = Period("2011-04-02", freq="D")
+        assert result == exp
+
+        result = p - offsets.Day(2)
+        exp = Period("2011-03-30", freq="D")
+        assert result == exp
+
+        msg = r"Input cannot be converted to Period\(freq=D\)"
+        with pytest.raises(IncompatibleFrequency, match=msg):
+            p + offsets.Hour(2)
+
+        with pytest.raises(IncompatibleFrequency, match=msg):
+            p - offsets.Hour(2)
+
+
+def test_period_immutable():
+    # see gh-17116
+    msg = "not writable"
+
+    per = Period("2014Q1")
+    with pytest.raises(AttributeError, match=msg):
+        per.ordinal = 14
+
+    freq = per.freq
+    with pytest.raises(AttributeError, match=msg):
+        per.freq = 2 * freq
+
+
+def test_small_year_parsing():
+    per1 = Period("0001-01-07", "D")
+    assert per1.year == 1
+    assert per1.day == 7
+
+
+def test_negone_ordinals():
+    freqs = ["A", "M", "Q", "D", "H", "T", "S"]
+
+    period = Period(ordinal=-1, freq="D")
+    for freq in freqs:
+        repr(period.asfreq(freq))
+
+    for freq in freqs:
+        period = Period(ordinal=-1, freq=freq)
+        repr(period)
+        assert period.year == 1969
+
+    period = Period(ordinal=-1, freq="B")
+    repr(period)
+    period = Period(ordinal=-1, freq="W")
+    repr(period)
+
+
+def test_invalid_frequency_error_message():
+    msg = "Invalid frequency: <WeekOfMonth: week=0, weekday=0>"
+    with pytest.raises(ValueError, match=msg):
+        Period("2012-01-02", freq="WOM-1MON")

videochat2/lib/python3.10/site-packages/pandas/tests/scalar/test_na_scalar.py

@@ -0,0 +1,316 @@
+from datetime import (
+    date,
+    time,
+    timedelta,
+)
+import pickle
+
+import numpy as np
+import pytest
+
+from pandas._libs.missing import NA
+
+from pandas.core.dtypes.common import is_scalar
+
+import pandas as pd
+import pandas._testing as tm
+
+
+def test_singleton():
+    assert NA is NA
+    new_NA = type(NA)()
+    assert new_NA is NA
+
+
+def test_repr():
+    assert repr(NA) == "<NA>"
+    assert str(NA) == "<NA>"
+
+
+def test_format():
+    # GH-34740
+    assert format(NA) == "<NA>"
+    assert format(NA, ">10") == "      <NA>"
+    assert format(NA, "xxx") == "<NA>"  # NA is flexible, accept any format spec
+
+    assert f"{NA}" == "<NA>"
+    assert f"{NA:>10}" == "      <NA>"
+    assert f"{NA:xxx}" == "<NA>"
+
+
+def test_truthiness():
+    msg = "boolean value of NA is ambiguous"
+
+    with pytest.raises(TypeError, match=msg):
+        bool(NA)
+
+    with pytest.raises(TypeError, match=msg):
+        not NA
+
+
+def test_hashable():
+    assert hash(NA) == hash(NA)
+    d = {NA: "test"}
+    assert d[NA] == "test"
+
+
+@pytest.mark.parametrize(
+    "other", [NA, 1, 1.0, "a", b"a", np.int64(1), np.nan], ids=repr
+)
+def test_arithmetic_ops(all_arithmetic_functions, other):
+    op = all_arithmetic_functions
+
+    if op.__name__ in ("pow", "rpow", "rmod") and isinstance(other, (str, bytes)):
+        pytest.skip(reason=f"{op.__name__} with NA and {other} not defined.")
+    if op.__name__ in ("divmod", "rdivmod"):
+        assert op(NA, other) is (NA, NA)
+    else:
+        if op.__name__ == "rpow":
+            # avoid special case
+            other += 1
+        assert op(NA, other) is NA
+
+
+@pytest.mark.parametrize(
+    "other",
+    [
+        NA,
+        1,
+        1.0,
+        "a",
+        b"a",
+        np.int64(1),
+        np.nan,
+        np.bool_(True),
+        time(0),
+        date(1, 2, 3),
+        timedelta(1),
+        pd.NaT,
+    ],
+)
+def test_comparison_ops(comparison_op, other):
+    assert comparison_op(NA, other) is NA
+    assert comparison_op(other, NA) is NA
+
+
+@pytest.mark.parametrize(
+    "value",
+    [
+        0,
+        0.0,
+        -0,
+        -0.0,
+        False,
+        np.bool_(False),
+        np.int_(0),
+        np.float_(0),
+        np.int_(-0),
+        np.float_(-0),
+    ],
+)
+@pytest.mark.parametrize("asarray", [True, False])
+def test_pow_special(value, asarray):
+    if asarray:
+        value = np.array([value])
+    result = NA**value
+
+    if asarray:
+        result = result[0]
+    else:
+        # this assertion isn't possible for ndarray.
+        assert isinstance(result, type(value))
+    assert result == 1
+
+
+@pytest.mark.parametrize(
+    "value", [1, 1.0, True, np.bool_(True), np.int_(1), np.float_(1)]
+)
+@pytest.mark.parametrize("asarray", [True, False])
+def test_rpow_special(value, asarray):
+    if asarray:
+        value = np.array([value])
+    result = value**NA
+
+    if asarray:
+        result = result[0]
+    elif not isinstance(value, (np.float_, np.bool_, np.int_)):
+        # this assertion isn't possible with asarray=True
+        assert isinstance(result, type(value))
+
+    assert result == value
+
+
+@pytest.mark.parametrize("value", [-1, -1.0, np.int_(-1), np.float_(-1)])
+@pytest.mark.parametrize("asarray", [True, False])
+def test_rpow_minus_one(value, asarray):
+    if asarray:
+        value = np.array([value])
+    result = value**NA
+
+    if asarray:
+        result = result[0]
+
+    assert pd.isna(result)
+
+
+def test_unary_ops():
+    assert +NA is NA
+    assert -NA is NA
+    assert abs(NA) is NA
+    assert ~NA is NA
+
+
+def test_logical_and():
+    assert NA & True is NA
+    assert True & NA is NA
+    assert NA & False is False
+    assert False & NA is False
+    assert NA & NA is NA
+
+    msg = "unsupported operand type"
+    with pytest.raises(TypeError, match=msg):
+        NA & 5
+
+
+def test_logical_or():
+    assert NA | True is True
+    assert True | NA is True
+    assert NA | False is NA
+    assert False | NA is NA
+    assert NA | NA is NA
+
+    msg = "unsupported operand type"
+    with pytest.raises(TypeError, match=msg):
+        NA | 5
+
+
+def test_logical_xor():
+    assert NA ^ True is NA
+    assert True ^ NA is NA
+    assert NA ^ False is NA
+    assert False ^ NA is NA
+    assert NA ^ NA is NA
+
+    msg = "unsupported operand type"
+    with pytest.raises(TypeError, match=msg):
+        NA ^ 5
+
+
+def test_logical_not():
+    assert ~NA is NA
+
+
+@pytest.mark.parametrize("shape", [(3,), (3, 3), (1, 2, 3)])
+def test_arithmetic_ndarray(shape, all_arithmetic_functions):
+    op = all_arithmetic_functions
+    a = np.zeros(shape)
+    if op.__name__ == "pow":
+        a += 5
+    result = op(NA, a)
+    expected = np.full(a.shape, NA, dtype=object)
+    tm.assert_numpy_array_equal(result, expected)
+
+
+def test_is_scalar():
+    assert is_scalar(NA) is True
+
+
+def test_isna():
+    assert pd.isna(NA) is True
+    assert pd.notna(NA) is False
+
+
+def test_series_isna():
+    s = pd.Series([1, NA], dtype=object)
+    expected = pd.Series([False, True])
+    tm.assert_series_equal(s.isna(), expected)
+
+
+def test_ufunc():
+    assert np.log(NA) is NA
+    assert np.add(NA, 1) is NA
+    result = np.divmod(NA, 1)
+    assert result[0] is NA and result[1] is NA
+
+    result = np.frexp(NA)
+    assert result[0] is NA and result[1] is NA
+
+
+def test_ufunc_raises():
+    msg = "ufunc method 'at'"
+    with pytest.raises(ValueError, match=msg):
+        np.log.at(NA, 0)
+
+
+def test_binary_input_not_dunder():
+    a = np.array([1, 2, 3])
+    expected = np.array([NA, NA, NA], dtype=object)
+    result = np.logaddexp(a, NA)
+    tm.assert_numpy_array_equal(result, expected)
+
+    result = np.logaddexp(NA, a)
+    tm.assert_numpy_array_equal(result, expected)
+
+    # all NA, multiple inputs
+    assert np.logaddexp(NA, NA) is NA
+
+    result = np.modf(NA, NA)
+    assert len(result) == 2
+    assert all(x is NA for x in result)
+
+
+def test_divmod_ufunc():
+    # binary in, binary out.
+    a = np.array([1, 2, 3])
+    expected = np.array([NA, NA, NA], dtype=object)
+
+    result = np.divmod(a, NA)
+    assert isinstance(result, tuple)
+    for arr in result:
+        tm.assert_numpy_array_equal(arr, expected)
+        tm.assert_numpy_array_equal(arr, expected)
+
+    result = np.divmod(NA, a)
+    for arr in result:
+        tm.assert_numpy_array_equal(arr, expected)
+        tm.assert_numpy_array_equal(arr, expected)
+
+
+def test_integer_hash_collision_dict():
+    # GH 30013
+    result = {NA: "foo", hash(NA): "bar"}
+
+    assert result[NA] == "foo"
+    assert result[hash(NA)] == "bar"
+
+
+def test_integer_hash_collision_set():
+    # GH 30013
+    result = {NA, hash(NA)}
+
+    assert len(result) == 2
+    assert NA in result
+    assert hash(NA) in result
+
+
+def test_pickle_roundtrip():
+    # https://github.com/pandas-dev/pandas/issues/31847
+    result = pickle.loads(pickle.dumps(NA))
+    assert result is NA
+
+
+def test_pickle_roundtrip_pandas():
+    result = tm.round_trip_pickle(NA)
+    assert result is NA
+
+
+@pytest.mark.parametrize(
+    "values, dtype", [([1, 2, NA], "Int64"), (["A", "B", NA], "string")]
+)
+@pytest.mark.parametrize("as_frame", [True, False])
+def test_pickle_roundtrip_containers(as_frame, values, dtype):
+    s = pd.Series(pd.array(values, dtype=dtype))
+    if as_frame:
+        s = s.to_frame(name="A")
+    result = tm.round_trip_pickle(s)
+    tm.assert_equal(result, s)

videochat2/lib/python3.10/site-packages/pandas/tests/scalar/test_nat.py

@@ -0,0 +1,696 @@
+from datetime import (
+    datetime,
+    timedelta,
+)
+import operator
+
+import numpy as np
+import pytest
+import pytz
+
+from pandas._libs.tslibs import iNaT
+from pandas.compat.numpy import np_version_gte1p24p3
+
+from pandas.core.dtypes.common import is_datetime64_any_dtype
+
+from pandas import (
+    DatetimeIndex,
+    DatetimeTZDtype,
+    Index,
+    NaT,
+    Period,
+    Series,
+    Timedelta,
+    TimedeltaIndex,
+    Timestamp,
+    isna,
+    offsets,
+)
+import pandas._testing as tm
+from pandas.core.arrays import (
+    DatetimeArray,
+    PeriodArray,
+    TimedeltaArray,
+)
+from pandas.core.ops import roperator
+
+
+@pytest.mark.parametrize(
+    "nat,idx",
+    [
+        (Timestamp("NaT"), DatetimeArray),
+        (Timedelta("NaT"), TimedeltaArray),
+        (Period("NaT", freq="M"), PeriodArray),
+    ],
+)
+def test_nat_fields(nat, idx):
+    for field in idx._field_ops:
+        # weekday is a property of DTI, but a method
+        # on NaT/Timestamp for compat with datetime
+        if field == "weekday":
+            continue
+
+        result = getattr(NaT, field)
+        assert np.isnan(result)
+
+        result = getattr(nat, field)
+        assert np.isnan(result)
+
+    for field in idx._bool_ops:
+        result = getattr(NaT, field)
+        assert result is False
+
+        result = getattr(nat, field)
+        assert result is False
+
+
+def test_nat_vector_field_access():
+    idx = DatetimeIndex(["1/1/2000", None, None, "1/4/2000"])
+
+    for field in DatetimeArray._field_ops:
+        # weekday is a property of DTI, but a method
+        # on NaT/Timestamp for compat with datetime
+        if field == "weekday":
+            continue
+
+        result = getattr(idx, field)
+        expected = Index([getattr(x, field) for x in idx])
+        tm.assert_index_equal(result, expected)
+
+    ser = Series(idx)
+
+    for field in DatetimeArray._field_ops:
+        # weekday is a property of DTI, but a method
+        # on NaT/Timestamp for compat with datetime
+        if field == "weekday":
+            continue
+
+        result = getattr(ser.dt, field)
+        expected = [getattr(x, field) for x in idx]
+        tm.assert_series_equal(result, Series(expected))
+
+    for field in DatetimeArray._bool_ops:
+        result = getattr(ser.dt, field)
+        expected = [getattr(x, field) for x in idx]
+        tm.assert_series_equal(result, Series(expected))
+
+
+@pytest.mark.parametrize("klass", [Timestamp, Timedelta, Period])
+@pytest.mark.parametrize(
+    "value", [None, np.nan, iNaT, float("nan"), NaT, "NaT", "nat", "", "NAT"]
+)
+def test_identity(klass, value):
+    assert klass(value) is NaT
+
+
+@pytest.mark.parametrize("klass", [Timestamp, Timedelta])
+@pytest.mark.parametrize("method", ["round", "floor", "ceil"])
+@pytest.mark.parametrize("freq", ["s", "5s", "min", "5min", "h", "5h"])
+def test_round_nat(klass, method, freq):
+    # see gh-14940
+    ts = klass("nat")
+
+    round_method = getattr(ts, method)
+    assert round_method(freq) is ts
+
+
+@pytest.mark.parametrize(
+    "method",
+    [
+        "astimezone",
+        "combine",
+        "ctime",
+        "dst",
+        "fromordinal",
+        "fromtimestamp",
+        "fromisocalendar",
+        "isocalendar",
+        "strftime",
+        "strptime",
+        "time",
+        "timestamp",
+        "timetuple",
+        "timetz",
+        "toordinal",
+        "tzname",
+        "utcfromtimestamp",
+        "utcnow",
+        "utcoffset",
+        "utctimetuple",
+        "timestamp",
+    ],
+)
+def test_nat_methods_raise(method):
+    # see gh-9513, gh-17329
+    msg = f"NaTType does not support {method}"
+
+    with pytest.raises(ValueError, match=msg):
+        getattr(NaT, method)()
+
+
+@pytest.mark.parametrize("method", ["weekday", "isoweekday"])
+def test_nat_methods_nan(method):
+    # see gh-9513, gh-17329
+    assert np.isnan(getattr(NaT, method)())
+
+
+@pytest.mark.parametrize(
+    "method", ["date", "now", "replace", "today", "tz_convert", "tz_localize"]
+)
+def test_nat_methods_nat(method):
+    # see gh-8254, gh-9513, gh-17329
+    assert getattr(NaT, method)() is NaT
+
+
+@pytest.mark.parametrize(
+    "get_nat", [lambda x: NaT, lambda x: Timedelta(x), lambda x: Timestamp(x)]
+)
+def test_nat_iso_format(get_nat):
+    # see gh-12300
+    assert get_nat("NaT").isoformat() == "NaT"
+    assert get_nat("NaT").isoformat(timespec="nanoseconds") == "NaT"
+
+
+@pytest.mark.parametrize(
+    "klass,expected",
+    [
+        (Timestamp, ["normalize", "to_julian_date", "to_period", "unit"]),
+        (
+            Timedelta,
+            [
+                "components",
+                "resolution_string",
+                "to_pytimedelta",
+                "to_timedelta64",
+                "unit",
+                "view",
+            ],
+        ),
+    ],
+)
+def test_missing_public_nat_methods(klass, expected):
+    # see gh-17327
+    #
+    # NaT should have *most* of the Timestamp and Timedelta methods.
+    # Here, we check which public methods NaT does not have. We
+    # ignore any missing private methods.
+    nat_names = dir(NaT)
+    klass_names = dir(klass)
+
+    missing = [x for x in klass_names if x not in nat_names and not x.startswith("_")]
+    missing.sort()
+
+    assert missing == expected
+
+
+def _get_overlap_public_nat_methods(klass, as_tuple=False):
+    """
+    Get overlapping public methods between NaT and another class.
+
+    Parameters
+    ----------
+    klass : type
+        The class to compare with NaT
+    as_tuple : bool, default False
+        Whether to return a list of tuples of the form (klass, method).
+
+    Returns
+    -------
+    overlap : list
+    """
+    nat_names = dir(NaT)
+    klass_names = dir(klass)
+
+    overlap = [
+        x
+        for x in nat_names
+        if x in klass_names and not x.startswith("_") and callable(getattr(klass, x))
+    ]
+
+    # Timestamp takes precedence over Timedelta in terms of overlap.
+    if klass is Timedelta:
+        ts_names = dir(Timestamp)
+        overlap = [x for x in overlap if x not in ts_names]
+
+    if as_tuple:
+        overlap = [(klass, method) for method in overlap]
+
+    overlap.sort()
+    return overlap
+
+
+@pytest.mark.parametrize(
+    "klass,expected",
+    [
+        (
+            Timestamp,
+            [
+                "as_unit",
+                "astimezone",
+                "ceil",
+                "combine",
+                "ctime",
+                "date",
+                "day_name",
+                "dst",
+                "floor",
+                "fromisocalendar",
+                "fromisoformat",
+                "fromordinal",
+                "fromtimestamp",
+                "isocalendar",
+                "isoformat",
+                "isoweekday",
+                "month_name",
+                "now",
+                "replace",
+                "round",
+                "strftime",
+                "strptime",
+                "time",
+                "timestamp",
+                "timetuple",
+                "timetz",
+                "to_datetime64",
+                "to_numpy",
+                "to_pydatetime",
+                "today",
+                "toordinal",
+                "tz_convert",
+                "tz_localize",
+                "tzname",
+                "utcfromtimestamp",
+                "utcnow",
+                "utcoffset",
+                "utctimetuple",
+                "weekday",
+            ],
+        ),
+        (Timedelta, ["total_seconds"]),
+    ],
+)
+def test_overlap_public_nat_methods(klass, expected):
+    # see gh-17327
+    #
+    # NaT should have *most* of the Timestamp and Timedelta methods.
+    # In case when Timestamp, Timedelta, and NaT are overlap, the overlap
+    # is considered to be with Timestamp and NaT, not Timedelta.
+    assert _get_overlap_public_nat_methods(klass) == expected
+
+
+@pytest.mark.parametrize(
+    "compare",
+    (
+        _get_overlap_public_nat_methods(Timestamp, True)
+        + _get_overlap_public_nat_methods(Timedelta, True)
+    ),
+    ids=lambda x: f"{x[0].__name__}.{x[1]}",
+)
+def test_nat_doc_strings(compare):
+    # see gh-17327
+    #
+    # The docstrings for overlapping methods should match.
+    klass, method = compare
+    klass_doc = getattr(klass, method).__doc__
+
+    # Ignore differences with Timestamp.isoformat() as they're intentional
+    if klass == Timestamp and method == "isoformat":
+        return
+
+    if method == "to_numpy":
+        # GH#44460 can return either dt64 or td64 depending on dtype,
+        #  different docstring is intentional
+        return
+
+    nat_doc = getattr(NaT, method).__doc__
+    assert klass_doc == nat_doc
+
+
+_ops = {
+    "left_plus_right": lambda a, b: a + b,
+    "right_plus_left": lambda a, b: b + a,
+    "left_minus_right": lambda a, b: a - b,
+    "right_minus_left": lambda a, b: b - a,
+    "left_times_right": lambda a, b: a * b,
+    "right_times_left": lambda a, b: b * a,
+    "left_div_right": lambda a, b: a / b,
+    "right_div_left": lambda a, b: b / a,
+}
+
+
+@pytest.mark.parametrize("op_name", list(_ops.keys()))
+@pytest.mark.parametrize(
+    "value,val_type",
+    [
+        (2, "scalar"),
+        (1.5, "floating"),
+        (np.nan, "floating"),
+        ("foo", "str"),
+        (timedelta(3600), "timedelta"),
+        (Timedelta("5s"), "timedelta"),
+        (datetime(2014, 1, 1), "timestamp"),
+        (Timestamp("2014-01-01"), "timestamp"),
+        (Timestamp("2014-01-01", tz="UTC"), "timestamp"),
+        (Timestamp("2014-01-01", tz="US/Eastern"), "timestamp"),
+        (pytz.timezone("Asia/Tokyo").localize(datetime(2014, 1, 1)), "timestamp"),
+    ],
+)
+def test_nat_arithmetic_scalar(op_name, value, val_type):
+    # see gh-6873
+    invalid_ops = {
+        "scalar": {"right_div_left"},
+        "floating": {
+            "right_div_left",
+            "left_minus_right",
+            "right_minus_left",
+            "left_plus_right",
+            "right_plus_left",
+        },
+        "str": set(_ops.keys()),
+        "timedelta": {"left_times_right", "right_times_left"},
+        "timestamp": {
+            "left_times_right",
+            "right_times_left",
+            "left_div_right",
+            "right_div_left",
+        },
+    }
+
+    op = _ops[op_name]
+
+    if op_name in invalid_ops.get(val_type, set()):
+        if (
+            val_type == "timedelta"
+            and "times" in op_name
+            and isinstance(value, Timedelta)
+        ):
+            typs = "(Timedelta|NaTType)"
+            msg = rf"unsupported operand type\(s\) for \*: '{typs}' and '{typs}'"
+        elif val_type == "str":
+            # un-specific check here because the message comes from str
+            #  and varies by method
+            msg = "|".join(
+                [
+                    "can only concatenate str",
+                    "unsupported operand type",
+                    "can't multiply sequence",
+                    "Can't convert 'NaTType'",
+                    "must be str, not NaTType",
+                ]
+            )
+        else:
+            msg = "unsupported operand type"
+
+        with pytest.raises(TypeError, match=msg):
+            op(NaT, value)
+    else:
+        if val_type == "timedelta" and "div" in op_name:
+            expected = np.nan
+        else:
+            expected = NaT
+
+        assert op(NaT, value) is expected
+
+
+@pytest.mark.parametrize(
+    "val,expected", [(np.nan, NaT), (NaT, np.nan), (np.timedelta64("NaT"), np.nan)]
+)
+def test_nat_rfloordiv_timedelta(val, expected):
+    # see gh-#18846
+    #
+    # See also test_timedelta.TestTimedeltaArithmetic.test_floordiv
+    td = Timedelta(hours=3, minutes=4)
+    assert td // val is expected
+
+
+@pytest.mark.parametrize(
+    "op_name",
+    ["left_plus_right", "right_plus_left", "left_minus_right", "right_minus_left"],
+)
+@pytest.mark.parametrize(
+    "value",
+    [
+        DatetimeIndex(["2011-01-01", "2011-01-02"], name="x"),
+        DatetimeIndex(["2011-01-01", "2011-01-02"], tz="US/Eastern", name="x"),
+        DatetimeArray._from_sequence(["2011-01-01", "2011-01-02"]),
+        DatetimeArray._from_sequence(
+            ["2011-01-01", "2011-01-02"], dtype=DatetimeTZDtype(tz="US/Pacific")
+        ),
+        TimedeltaIndex(["1 day", "2 day"], name="x"),
+    ],
+)
+def test_nat_arithmetic_index(op_name, value):
+    # see gh-11718
+    exp_name = "x"
+    exp_data = [NaT] * 2
+
+    if is_datetime64_any_dtype(value.dtype) and "plus" in op_name:
+        expected = DatetimeIndex(exp_data, tz=value.tz, name=exp_name)
+    else:
+        expected = TimedeltaIndex(exp_data, name=exp_name)
+
+    if not isinstance(value, Index):
+        expected = expected.array
+
+    op = _ops[op_name]
+    result = op(NaT, value)
+    tm.assert_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "op_name",
+    ["left_plus_right", "right_plus_left", "left_minus_right", "right_minus_left"],
+)
+@pytest.mark.parametrize("box", [TimedeltaIndex, Series, TimedeltaArray._from_sequence])
+def test_nat_arithmetic_td64_vector(op_name, box):
+    # see gh-19124
+    vec = box(["1 day", "2 day"], dtype="timedelta64[ns]")
+    box_nat = box([NaT, NaT], dtype="timedelta64[ns]")
+    tm.assert_equal(_ops[op_name](vec, NaT), box_nat)
+
+
+@pytest.mark.parametrize(
+    "dtype,op,out_dtype",
+    [
+        ("datetime64[ns]", operator.add, "datetime64[ns]"),
+        ("datetime64[ns]", roperator.radd, "datetime64[ns]"),
+        ("datetime64[ns]", operator.sub, "timedelta64[ns]"),
+        ("datetime64[ns]", roperator.rsub, "timedelta64[ns]"),
+        ("timedelta64[ns]", operator.add, "datetime64[ns]"),
+        ("timedelta64[ns]", roperator.radd, "datetime64[ns]"),
+        ("timedelta64[ns]", operator.sub, "datetime64[ns]"),
+        ("timedelta64[ns]", roperator.rsub, "timedelta64[ns]"),
+    ],
+)
+def test_nat_arithmetic_ndarray(dtype, op, out_dtype):
+    other = np.arange(10).astype(dtype)
+    result = op(NaT, other)
+
+    expected = np.empty(other.shape, dtype=out_dtype)
+    expected.fill("NaT")
+    tm.assert_numpy_array_equal(result, expected)
+
+
+def test_nat_pinned_docstrings():
+    # see gh-17327
+    assert NaT.ctime.__doc__ == datetime.ctime.__doc__
+
+
+def test_to_numpy_alias():
+    # GH 24653: alias .to_numpy() for scalars
+    expected = NaT.to_datetime64()
+    result = NaT.to_numpy()
+
+    assert isna(expected) and isna(result)
+
+    # GH#44460
+    result = NaT.to_numpy("M8[s]")
+    assert isinstance(result, np.datetime64)
+    assert result.dtype == "M8[s]"
+
+    result = NaT.to_numpy("m8[ns]")
+    assert isinstance(result, np.timedelta64)
+    assert result.dtype == "m8[ns]"
+
+    result = NaT.to_numpy("m8[s]")
+    assert isinstance(result, np.timedelta64)
+    assert result.dtype == "m8[s]"
+
+    with pytest.raises(ValueError, match="NaT.to_numpy dtype must be a "):
+        NaT.to_numpy(np.int64)
+
+
+@pytest.mark.parametrize(
+    "other",
+    [
+        Timedelta(0),
+        Timedelta(0).to_pytimedelta(),
+        pytest.param(
+            Timedelta(0).to_timedelta64(),
+            marks=pytest.mark.xfail(
+                not np_version_gte1p24p3,
+                reason="td64 doesn't return NotImplemented, see numpy#17017",
+            ),
+        ),
+        Timestamp(0),
+        Timestamp(0).to_pydatetime(),
+        pytest.param(
+            Timestamp(0).to_datetime64(),
+            marks=pytest.mark.xfail(
+                not np_version_gte1p24p3,
+                reason="dt64 doesn't return NotImplemented, see numpy#17017",
+            ),
+        ),
+        Timestamp(0).tz_localize("UTC"),
+        NaT,
+    ],
+)
+def test_nat_comparisons(compare_operators_no_eq_ne, other):
+    # GH 26039
+    opname = compare_operators_no_eq_ne
+
+    assert getattr(NaT, opname)(other) is False
+
+    op = getattr(operator, opname.strip("_"))
+    assert op(NaT, other) is False
+    assert op(other, NaT) is False
+
+
+@pytest.mark.parametrize("other", [np.timedelta64(0, "ns"), np.datetime64("now", "ns")])
+def test_nat_comparisons_numpy(other):
+    # Once numpy#17017 is fixed and the xfailed cases in test_nat_comparisons
+    #  pass, this test can be removed
+    assert not NaT == other
+    assert NaT != other
+    assert not NaT < other
+    assert not NaT > other
+    assert not NaT <= other
+    assert not NaT >= other
+
+
+@pytest.mark.parametrize("other_and_type", [("foo", "str"), (2, "int"), (2.0, "float")])
+@pytest.mark.parametrize(
+    "symbol_and_op",
+    [("<=", operator.le), ("<", operator.lt), (">=", operator.ge), (">", operator.gt)],
+)
+def test_nat_comparisons_invalid(other_and_type, symbol_and_op):
+    # GH#35585
+    other, other_type = other_and_type
+    symbol, op = symbol_and_op
+
+    assert not NaT == other
+    assert not other == NaT
+
+    assert NaT != other
+    assert other != NaT
+
+    msg = f"'{symbol}' not supported between instances of 'NaTType' and '{other_type}'"
+    with pytest.raises(TypeError, match=msg):
+        op(NaT, other)
+
+    msg = f"'{symbol}' not supported between instances of '{other_type}' and 'NaTType'"
+    with pytest.raises(TypeError, match=msg):
+        op(other, NaT)
+
+
+@pytest.mark.parametrize(
+    "other",
+    [
+        np.array(["foo"] * 2, dtype=object),
+        np.array([2, 3], dtype="int64"),
+        np.array([2.0, 3.5], dtype="float64"),
+    ],
+    ids=["str", "int", "float"],
+)
+def test_nat_comparisons_invalid_ndarray(other):
+    # GH#40722
+    expected = np.array([False, False])
+    result = NaT == other
+    tm.assert_numpy_array_equal(result, expected)
+    result = other == NaT
+    tm.assert_numpy_array_equal(result, expected)
+
+    expected = np.array([True, True])
+    result = NaT != other
+    tm.assert_numpy_array_equal(result, expected)
+    result = other != NaT
+    tm.assert_numpy_array_equal(result, expected)
+
+    for symbol, op in [
+        ("<=", operator.le),
+        ("<", operator.lt),
+        (">=", operator.ge),
+        (">", operator.gt),
+    ]:
+        msg = f"'{symbol}' not supported between"
+
+        with pytest.raises(TypeError, match=msg):
+            op(NaT, other)
+
+        if other.dtype == np.dtype("object"):
+            # uses the reverse operator, so symbol changes
+            msg = None
+        with pytest.raises(TypeError, match=msg):
+            op(other, NaT)
+
+
+def test_compare_date(fixed_now_ts):
+    # GH#39151 comparing NaT with date object is deprecated
+    # See also: tests.scalar.timestamps.test_comparisons::test_compare_date
+
+    dt = fixed_now_ts.to_pydatetime().date()
+
+    msg = "Cannot compare NaT with datetime.date object"
+    for left, right in [(NaT, dt), (dt, NaT)]:
+        assert not left == right
+        assert left != right
+
+        with pytest.raises(TypeError, match=msg):
+            left < right
+        with pytest.raises(TypeError, match=msg):
+            left <= right
+        with pytest.raises(TypeError, match=msg):
+            left > right
+        with pytest.raises(TypeError, match=msg):
+            left >= right
+
+
+@pytest.mark.parametrize(
+    "obj",
+    [
+        offsets.YearEnd(2),
+        offsets.YearBegin(2),
+        offsets.MonthBegin(1),
+        offsets.MonthEnd(2),
+        offsets.MonthEnd(12),
+        offsets.Day(2),
+        offsets.Day(5),
+        offsets.Hour(24),
+        offsets.Hour(3),
+        offsets.Minute(),
+        np.timedelta64(3, "h"),
+        np.timedelta64(4, "h"),
+        np.timedelta64(3200, "s"),
+        np.timedelta64(3600, "s"),
+        np.timedelta64(3600 * 24, "s"),
+        np.timedelta64(2, "D"),
+        np.timedelta64(365, "D"),
+        timedelta(-2),
+        timedelta(365),
+        timedelta(minutes=120),
+        timedelta(days=4, minutes=180),
+        timedelta(hours=23),
+        timedelta(hours=23, minutes=30),
+        timedelta(hours=48),
+    ],
+)
+def test_nat_addsub_tdlike_scalar(obj):
+    assert NaT + obj is NaT
+    assert obj + NaT is NaT
+    assert NaT - obj is NaT
+
+
+def test_pickle():
+    # GH#4606
+    p = tm.round_trip_pickle(NaT)
+    assert p is NaT

videochat2/lib/python3.10/site-packages/pandas/tests/scalar/timedelta/test_arithmetic.py

@@ -0,0 +1,1181 @@
+"""
+Tests for scalar Timedelta arithmetic ops
+"""
+from datetime import (
+    datetime,
+    timedelta,
+)
+import operator
+
+import numpy as np
+import pytest
+
+from pandas.errors import OutOfBoundsTimedelta
+
+import pandas as pd
+from pandas import (
+    NaT,
+    Timedelta,
+    Timestamp,
+    offsets,
+)
+import pandas._testing as tm
+from pandas.core import ops
+
+
+class TestTimedeltaAdditionSubtraction:
+    """
+    Tests for Timedelta methods:
+
+        __add__, __radd__,
+        __sub__, __rsub__
+    """
+
+    @pytest.mark.parametrize(
+        "ten_seconds",
+        [
+            Timedelta(10, unit="s"),
+            timedelta(seconds=10),
+            np.timedelta64(10, "s"),
+            np.timedelta64(10000000000, "ns"),
+            offsets.Second(10),
+        ],
+    )
+    def test_td_add_sub_ten_seconds(self, ten_seconds):
+        # GH#6808
+        base = Timestamp("20130101 09:01:12.123456")
+        expected_add = Timestamp("20130101 09:01:22.123456")
+        expected_sub = Timestamp("20130101 09:01:02.123456")
+
+        result = base + ten_seconds
+        assert result == expected_add
+
+        result = base - ten_seconds
+        assert result == expected_sub
+
+    @pytest.mark.parametrize(
+        "one_day_ten_secs",
+        [
+            Timedelta("1 day, 00:00:10"),
+            Timedelta("1 days, 00:00:10"),
+            timedelta(days=1, seconds=10),
+            np.timedelta64(1, "D") + np.timedelta64(10, "s"),
+            offsets.Day() + offsets.Second(10),
+        ],
+    )
+    def test_td_add_sub_one_day_ten_seconds(self, one_day_ten_secs):
+        # GH#6808
+        base = Timestamp("20130102 09:01:12.123456")
+        expected_add = Timestamp("20130103 09:01:22.123456")
+        expected_sub = Timestamp("20130101 09:01:02.123456")
+
+        result = base + one_day_ten_secs
+        assert result == expected_add
+
+        result = base - one_day_ten_secs
+        assert result == expected_sub
+
+    @pytest.mark.parametrize("op", [operator.add, ops.radd])
+    def test_td_add_datetimelike_scalar(self, op):
+        # GH#19738
+        td = Timedelta(10, unit="d")
+
+        result = op(td, datetime(2016, 1, 1))
+        if op is operator.add:
+            # datetime + Timedelta does _not_ call Timedelta.__radd__,
+            # so we get a datetime back instead of a Timestamp
+            assert isinstance(result, Timestamp)
+        assert result == Timestamp(2016, 1, 11)
+
+        result = op(td, Timestamp("2018-01-12 18:09"))
+        assert isinstance(result, Timestamp)
+        assert result == Timestamp("2018-01-22 18:09")
+
+        result = op(td, np.datetime64("2018-01-12"))
+        assert isinstance(result, Timestamp)
+        assert result == Timestamp("2018-01-22")
+
+        result = op(td, NaT)
+        assert result is NaT
+
+    def test_td_add_timestamp_overflow(self):
+        ts = Timestamp("1700-01-01").as_unit("ns")
+        msg = "Cannot cast 259987 from D to 'ns' without overflow."
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
+            ts + Timedelta(13 * 19999, unit="D")
+
+        msg = "Cannot cast 259987 days 00:00:00 to unit='ns' without overflow"
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
+            ts + timedelta(days=13 * 19999)
+
+    @pytest.mark.parametrize("op", [operator.add, ops.radd])
+    def test_td_add_td(self, op):
+        td = Timedelta(10, unit="d")
+
+        result = op(td, Timedelta(days=10))
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(days=20)
+
+    @pytest.mark.parametrize("op", [operator.add, ops.radd])
+    def test_td_add_pytimedelta(self, op):
+        td = Timedelta(10, unit="d")
+        result = op(td, timedelta(days=9))
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(days=19)
+
+    @pytest.mark.parametrize("op", [operator.add, ops.radd])
+    def test_td_add_timedelta64(self, op):
+        td = Timedelta(10, unit="d")
+        result = op(td, np.timedelta64(-4, "D"))
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(days=6)
+
+    @pytest.mark.parametrize("op", [operator.add, ops.radd])
+    def test_td_add_offset(self, op):
+        td = Timedelta(10, unit="d")
+
+        result = op(td, offsets.Hour(6))
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(days=10, hours=6)
+
+    def test_td_sub_td(self):
+        td = Timedelta(10, unit="d")
+        expected = Timedelta(0, unit="ns")
+        result = td - td
+        assert isinstance(result, Timedelta)
+        assert result == expected
+
+    def test_td_sub_pytimedelta(self):
+        td = Timedelta(10, unit="d")
+        expected = Timedelta(0, unit="ns")
+
+        result = td - td.to_pytimedelta()
+        assert isinstance(result, Timedelta)
+        assert result == expected
+
+        result = td.to_pytimedelta() - td
+        assert isinstance(result, Timedelta)
+        assert result == expected
+
+    def test_td_sub_timedelta64(self):
+        td = Timedelta(10, unit="d")
+        expected = Timedelta(0, unit="ns")
+
+        result = td - td.to_timedelta64()
+        assert isinstance(result, Timedelta)
+        assert result == expected
+
+        result = td.to_timedelta64() - td
+        assert isinstance(result, Timedelta)
+        assert result == expected
+
+    def test_td_sub_nat(self):
+        # In this context pd.NaT is treated as timedelta-like
+        td = Timedelta(10, unit="d")
+        result = td - NaT
+        assert result is NaT
+
+    def test_td_sub_td64_nat(self):
+        td = Timedelta(10, unit="d")
+        td_nat = np.timedelta64("NaT")
+
+        result = td - td_nat
+        assert result is NaT
+
+        result = td_nat - td
+        assert result is NaT
+
+    def test_td_sub_offset(self):
+        td = Timedelta(10, unit="d")
+        result = td - offsets.Hour(1)
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(239, unit="h")
+
+    def test_td_add_sub_numeric_raises(self):
+        td = Timedelta(10, unit="d")
+        msg = "unsupported operand type"
+        for other in [2, 2.0, np.int64(2), np.float64(2)]:
+            with pytest.raises(TypeError, match=msg):
+                td + other
+            with pytest.raises(TypeError, match=msg):
+                other + td
+            with pytest.raises(TypeError, match=msg):
+                td - other
+            with pytest.raises(TypeError, match=msg):
+                other - td
+
+    def test_td_add_sub_int_ndarray(self):
+        td = Timedelta("1 day")
+        other = np.array([1])
+
+        msg = r"unsupported operand type\(s\) for \+: 'Timedelta' and 'int'"
+        with pytest.raises(TypeError, match=msg):
+            td + np.array([1])
+
+        msg = "|".join(
+            [
+                (
+                    r"unsupported operand type\(s\) for \+: 'numpy.ndarray' "
+                    "and 'Timedelta'"
+                ),
+                # This message goes on to say "Please do not rely on this error;
+                #  it may not be given on all Python implementations"
+                "Concatenation operation is not implemented for NumPy arrays",
+            ]
+        )
+        with pytest.raises(TypeError, match=msg):
+            other + td
+        msg = r"unsupported operand type\(s\) for -: 'Timedelta' and 'int'"
+        with pytest.raises(TypeError, match=msg):
+            td - other
+        msg = r"unsupported operand type\(s\) for -: 'numpy.ndarray' and 'Timedelta'"
+        with pytest.raises(TypeError, match=msg):
+            other - td
+
+    def test_td_rsub_nat(self):
+        td = Timedelta(10, unit="d")
+        result = NaT - td
+        assert result is NaT
+
+        result = np.datetime64("NaT") - td
+        assert result is NaT
+
+    def test_td_rsub_offset(self):
+        result = offsets.Hour(1) - Timedelta(10, unit="d")
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(-239, unit="h")
+
+    def test_td_sub_timedeltalike_object_dtype_array(self):
+        # GH#21980
+        arr = np.array([Timestamp("20130101 9:01"), Timestamp("20121230 9:02")])
+        exp = np.array([Timestamp("20121231 9:01"), Timestamp("20121229 9:02")])
+        res = arr - Timedelta("1D")
+        tm.assert_numpy_array_equal(res, exp)
+
+    def test_td_sub_mixed_most_timedeltalike_object_dtype_array(self):
+        # GH#21980
+        now = Timestamp("2021-11-09 09:54:00")
+        arr = np.array([now, Timedelta("1D"), np.timedelta64(2, "h")])
+        exp = np.array(
+            [
+                now - Timedelta("1D"),
+                Timedelta("0D"),
+                np.timedelta64(2, "h") - Timedelta("1D"),
+            ]
+        )
+        res = arr - Timedelta("1D")
+        tm.assert_numpy_array_equal(res, exp)
+
+    def test_td_rsub_mixed_most_timedeltalike_object_dtype_array(self):
+        # GH#21980
+        now = Timestamp("2021-11-09 09:54:00")
+        arr = np.array([now, Timedelta("1D"), np.timedelta64(2, "h")])
+        msg = r"unsupported operand type\(s\) for \-: 'Timedelta' and 'Timestamp'"
+        with pytest.raises(TypeError, match=msg):
+            Timedelta("1D") - arr
+
+    @pytest.mark.parametrize("op", [operator.add, ops.radd])
+    def test_td_add_timedeltalike_object_dtype_array(self, op):
+        # GH#21980
+        arr = np.array([Timestamp("20130101 9:01"), Timestamp("20121230 9:02")])
+        exp = np.array([Timestamp("20130102 9:01"), Timestamp("20121231 9:02")])
+        res = op(arr, Timedelta("1D"))
+        tm.assert_numpy_array_equal(res, exp)
+
+    @pytest.mark.parametrize("op", [operator.add, ops.radd])
+    def test_td_add_mixed_timedeltalike_object_dtype_array(self, op):
+        # GH#21980
+        now = Timestamp("2021-11-09 09:54:00")
+        arr = np.array([now, Timedelta("1D")])
+        exp = np.array([now + Timedelta("1D"), Timedelta("2D")])
+        res = op(arr, Timedelta("1D"))
+        tm.assert_numpy_array_equal(res, exp)
+
+    def test_td_add_sub_td64_ndarray(self):
+        td = Timedelta("1 day")
+
+        other = np.array([td.to_timedelta64()])
+        expected = np.array([Timedelta("2 Days").to_timedelta64()])
+
+        result = td + other
+        tm.assert_numpy_array_equal(result, expected)
+        result = other + td
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = td - other
+        tm.assert_numpy_array_equal(result, expected * 0)
+        result = other - td
+        tm.assert_numpy_array_equal(result, expected * 0)
+
+    def test_td_add_sub_dt64_ndarray(self):
+        td = Timedelta("1 day")
+        other = pd.to_datetime(["2000-01-01"]).values
+
+        expected = pd.to_datetime(["2000-01-02"]).values
+        tm.assert_numpy_array_equal(td + other, expected)
+        tm.assert_numpy_array_equal(other + td, expected)
+
+        expected = pd.to_datetime(["1999-12-31"]).values
+        tm.assert_numpy_array_equal(-td + other, expected)
+        tm.assert_numpy_array_equal(other - td, expected)
+
+    def test_td_add_sub_ndarray_0d(self):
+        td = Timedelta("1 day")
+        other = np.array(td.asm8)
+
+        result = td + other
+        assert isinstance(result, Timedelta)
+        assert result == 2 * td
+
+        result = other + td
+        assert isinstance(result, Timedelta)
+        assert result == 2 * td
+
+        result = other - td
+        assert isinstance(result, Timedelta)
+        assert result == 0 * td
+
+        result = td - other
+        assert isinstance(result, Timedelta)
+        assert result == 0 * td
+
+
+class TestTimedeltaMultiplicationDivision:
+    """
+    Tests for Timedelta methods:
+
+        __mul__, __rmul__,
+        __div__, __rdiv__,
+        __truediv__, __rtruediv__,
+        __floordiv__, __rfloordiv__,
+        __mod__, __rmod__,
+        __divmod__, __rdivmod__
+    """
+
+    # ---------------------------------------------------------------
+    # Timedelta.__mul__, __rmul__
+
+    @pytest.mark.parametrize(
+        "td_nat", [NaT, np.timedelta64("NaT", "ns"), np.timedelta64("NaT")]
+    )
+    @pytest.mark.parametrize("op", [operator.mul, ops.rmul])
+    def test_td_mul_nat(self, op, td_nat):
+        # GH#19819
+        td = Timedelta(10, unit="d")
+        typs = "|".join(["numpy.timedelta64", "NaTType", "Timedelta"])
+        msg = "|".join(
+            [
+                rf"unsupported operand type\(s\) for \*: '{typs}' and '{typs}'",
+                r"ufunc '?multiply'? cannot use operands with types",
+            ]
+        )
+        with pytest.raises(TypeError, match=msg):
+            op(td, td_nat)
+
+    @pytest.mark.parametrize("nan", [np.nan, np.float64("NaN"), float("nan")])
+    @pytest.mark.parametrize("op", [operator.mul, ops.rmul])
+    def test_td_mul_nan(self, op, nan):
+        # np.float64('NaN') has a 'dtype' attr, avoid treating as array
+        td = Timedelta(10, unit="d")
+        result = op(td, nan)
+        assert result is NaT
+
+    @pytest.mark.parametrize("op", [operator.mul, ops.rmul])
+    def test_td_mul_scalar(self, op):
+        # GH#19738
+        td = Timedelta(minutes=3)
+
+        result = op(td, 2)
+        assert result == Timedelta(minutes=6)
+
+        result = op(td, 1.5)
+        assert result == Timedelta(minutes=4, seconds=30)
+
+        assert op(td, np.nan) is NaT
+
+        assert op(-1, td)._value == -1 * td._value
+        assert op(-1.0, td)._value == -1.0 * td._value
+
+        msg = "unsupported operand type"
+        with pytest.raises(TypeError, match=msg):
+            # timedelta * datetime is gibberish
+            op(td, Timestamp(2016, 1, 2))
+
+        with pytest.raises(TypeError, match=msg):
+            # invalid multiply with another timedelta
+            op(td, td)
+
+    def test_td_mul_numeric_ndarray(self):
+        td = Timedelta("1 day")
+        other = np.array([2])
+        expected = np.array([Timedelta("2 Days").to_timedelta64()])
+
+        result = td * other
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = other * td
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_td_mul_numeric_ndarray_0d(self):
+        td = Timedelta("1 day")
+        other = np.array(2)
+        assert other.ndim == 0
+        expected = Timedelta("2 days")
+
+        res = td * other
+        assert type(res) is Timedelta
+        assert res == expected
+
+        res = other * td
+        assert type(res) is Timedelta
+        assert res == expected
+
+    def test_td_mul_td64_ndarray_invalid(self):
+        td = Timedelta("1 day")
+        other = np.array([Timedelta("2 Days").to_timedelta64()])
+
+        msg = (
+            "ufunc '?multiply'? cannot use operands with types "
+            rf"dtype\('{tm.ENDIAN}m8\[ns\]'\) and dtype\('{tm.ENDIAN}m8\[ns\]'\)"
+        )
+        with pytest.raises(TypeError, match=msg):
+            td * other
+        with pytest.raises(TypeError, match=msg):
+            other * td
+
+    # ---------------------------------------------------------------
+    # Timedelta.__div__, __truediv__
+
+    def test_td_div_timedeltalike_scalar(self):
+        # GH#19738
+        td = Timedelta(10, unit="d")
+
+        result = td / offsets.Hour(1)
+        assert result == 240
+
+        assert td / td == 1
+        assert td / np.timedelta64(60, "h") == 4
+
+        assert np.isnan(td / NaT)
+
+    def test_td_div_td64_non_nano(self):
+        # truediv
+        td = Timedelta("1 days 2 hours 3 ns")
+        result = td / np.timedelta64(1, "D")
+        assert result == td._value / (86400 * 10**9)
+        result = td / np.timedelta64(1, "s")
+        assert result == td._value / 10**9
+        result = td / np.timedelta64(1, "ns")
+        assert result == td._value
+
+        # floordiv
+        td = Timedelta("1 days 2 hours 3 ns")
+        result = td // np.timedelta64(1, "D")
+        assert result == 1
+        result = td // np.timedelta64(1, "s")
+        assert result == 93600
+        result = td // np.timedelta64(1, "ns")
+        assert result == td._value
+
+    def test_td_div_numeric_scalar(self):
+        # GH#19738
+        td = Timedelta(10, unit="d")
+
+        result = td / 2
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(days=5)
+
+        result = td / 5
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(days=2)
+
+    @pytest.mark.parametrize(
+        "nan",
+        [
+            np.nan,
+            np.float64("NaN"),
+            float("nan"),
+        ],
+    )
+    def test_td_div_nan(self, nan):
+        # np.float64('NaN') has a 'dtype' attr, avoid treating as array
+        td = Timedelta(10, unit="d")
+        result = td / nan
+        assert result is NaT
+
+        result = td // nan
+        assert result is NaT
+
+    def test_td_div_td64_ndarray(self):
+        td = Timedelta("1 day")
+
+        other = np.array([Timedelta("2 Days").to_timedelta64()])
+        expected = np.array([0.5])
+
+        result = td / other
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = other / td
+        tm.assert_numpy_array_equal(result, expected * 4)
+
+    def test_td_div_ndarray_0d(self):
+        td = Timedelta("1 day")
+
+        other = np.array(1)
+        res = td / other
+        assert isinstance(res, Timedelta)
+        assert res == td
+
+    # ---------------------------------------------------------------
+    # Timedelta.__rdiv__
+
+    def test_td_rdiv_timedeltalike_scalar(self):
+        # GH#19738
+        td = Timedelta(10, unit="d")
+        result = offsets.Hour(1) / td
+        assert result == 1 / 240.0
+
+        assert np.timedelta64(60, "h") / td == 0.25
+
+    def test_td_rdiv_na_scalar(self):
+        # GH#31869 None gets cast to NaT
+        td = Timedelta(10, unit="d")
+
+        result = NaT / td
+        assert np.isnan(result)
+
+        result = None / td
+        assert np.isnan(result)
+
+        result = np.timedelta64("NaT") / td
+        assert np.isnan(result)
+
+        msg = r"unsupported operand type\(s\) for /: 'numpy.datetime64' and 'Timedelta'"
+        with pytest.raises(TypeError, match=msg):
+            np.datetime64("NaT") / td
+
+        msg = r"unsupported operand type\(s\) for /: 'float' and 'Timedelta'"
+        with pytest.raises(TypeError, match=msg):
+            np.nan / td
+
+    def test_td_rdiv_ndarray(self):
+        td = Timedelta(10, unit="d")
+
+        arr = np.array([td], dtype=object)
+        result = arr / td
+        expected = np.array([1], dtype=np.float64)
+        tm.assert_numpy_array_equal(result, expected)
+
+        arr = np.array([None])
+        result = arr / td
+        expected = np.array([np.nan])
+        tm.assert_numpy_array_equal(result, expected)
+
+        arr = np.array([np.nan], dtype=object)
+        msg = r"unsupported operand type\(s\) for /: 'float' and 'Timedelta'"
+        with pytest.raises(TypeError, match=msg):
+            arr / td
+
+        arr = np.array([np.nan], dtype=np.float64)
+        msg = "cannot use operands with types dtype"
+        with pytest.raises(TypeError, match=msg):
+            arr / td
+
+    def test_td_rdiv_ndarray_0d(self):
+        td = Timedelta(10, unit="d")
+
+        arr = np.array(td.asm8)
+
+        assert arr / td == 1
+
+    # ---------------------------------------------------------------
+    # Timedelta.__floordiv__
+
+    def test_td_floordiv_timedeltalike_scalar(self):
+        # GH#18846
+        td = Timedelta(hours=3, minutes=4)
+        scalar = Timedelta(hours=3, minutes=3)
+
+        assert td // scalar == 1
+        assert -td // scalar.to_pytimedelta() == -2
+        assert (2 * td) // scalar.to_timedelta64() == 2
+
+    def test_td_floordiv_null_scalar(self):
+        # GH#18846
+        td = Timedelta(hours=3, minutes=4)
+
+        assert td // np.nan is NaT
+        assert np.isnan(td // NaT)
+        assert np.isnan(td // np.timedelta64("NaT"))
+
+    def test_td_floordiv_offsets(self):
+        # GH#19738
+        td = Timedelta(hours=3, minutes=4)
+        assert td // offsets.Hour(1) == 3
+        assert td // offsets.Minute(2) == 92
+
+    def test_td_floordiv_invalid_scalar(self):
+        # GH#18846
+        td = Timedelta(hours=3, minutes=4)
+
+        msg = "|".join(
+            [
+                r"Invalid dtype datetime64\[D\] for __floordiv__",
+                "'dtype' is an invalid keyword argument for this function",
+                r"ufunc '?floor_divide'? cannot use operands with types",
+            ]
+        )
+        with pytest.raises(TypeError, match=msg):
+            td // np.datetime64("2016-01-01", dtype="datetime64[us]")
+
+    def test_td_floordiv_numeric_scalar(self):
+        # GH#18846
+        td = Timedelta(hours=3, minutes=4)
+
+        expected = Timedelta(hours=1, minutes=32)
+        assert td // 2 == expected
+        assert td // 2.0 == expected
+        assert td // np.float64(2.0) == expected
+        assert td // np.int32(2.0) == expected
+        assert td // np.uint8(2.0) == expected
+
+    def test_td_floordiv_timedeltalike_array(self):
+        # GH#18846
+        td = Timedelta(hours=3, minutes=4)
+        scalar = Timedelta(hours=3, minutes=3)
+
+        # Array-like others
+        assert td // np.array(scalar.to_timedelta64()) == 1
+
+        res = (3 * td) // np.array([scalar.to_timedelta64()])
+        expected = np.array([3], dtype=np.int64)
+        tm.assert_numpy_array_equal(res, expected)
+
+        res = (10 * td) // np.array([scalar.to_timedelta64(), np.timedelta64("NaT")])
+        expected = np.array([10, np.nan])
+        tm.assert_numpy_array_equal(res, expected)
+
+    def test_td_floordiv_numeric_series(self):
+        # GH#18846
+        td = Timedelta(hours=3, minutes=4)
+        ser = pd.Series([1], dtype=np.int64)
+        res = td // ser
+        assert res.dtype.kind == "m"
+
+    # ---------------------------------------------------------------
+    # Timedelta.__rfloordiv__
+
+    def test_td_rfloordiv_timedeltalike_scalar(self):
+        # GH#18846
+        td = Timedelta(hours=3, minutes=3)
+        scalar = Timedelta(hours=3, minutes=4)
+
+        # scalar others
+        # x // Timedelta is defined only for timedelta-like x. int-like,
+        # float-like, and date-like, in particular, should all either
+        # a) raise TypeError directly or
+        # b) return NotImplemented, following which the reversed
+        #    operation will raise TypeError.
+        assert td.__rfloordiv__(scalar) == 1
+        assert (-td).__rfloordiv__(scalar.to_pytimedelta()) == -2
+        assert (2 * td).__rfloordiv__(scalar.to_timedelta64()) == 0
+
+    def test_td_rfloordiv_null_scalar(self):
+        # GH#18846
+        td = Timedelta(hours=3, minutes=3)
+
+        assert np.isnan(td.__rfloordiv__(NaT))
+        assert np.isnan(td.__rfloordiv__(np.timedelta64("NaT")))
+
+    def test_td_rfloordiv_offsets(self):
+        # GH#19738
+        assert offsets.Hour(1) // Timedelta(minutes=25) == 2
+
+    def test_td_rfloordiv_invalid_scalar(self):
+        # GH#18846
+        td = Timedelta(hours=3, minutes=3)
+
+        dt64 = np.datetime64("2016-01-01", "us")
+
+        assert td.__rfloordiv__(dt64) is NotImplemented
+
+        msg = (
+            r"unsupported operand type\(s\) for //: 'numpy.datetime64' and 'Timedelta'"
+        )
+        with pytest.raises(TypeError, match=msg):
+            dt64 // td
+
+    def test_td_rfloordiv_numeric_scalar(self):
+        # GH#18846
+        td = Timedelta(hours=3, minutes=3)
+
+        assert td.__rfloordiv__(np.nan) is NotImplemented
+        assert td.__rfloordiv__(3.5) is NotImplemented
+        assert td.__rfloordiv__(2) is NotImplemented
+        assert td.__rfloordiv__(np.float64(2.0)) is NotImplemented
+        assert td.__rfloordiv__(np.uint8(9)) is NotImplemented
+        assert td.__rfloordiv__(np.int32(2.0)) is NotImplemented
+
+        msg = r"unsupported operand type\(s\) for //: '.*' and 'Timedelta"
+        with pytest.raises(TypeError, match=msg):
+            np.float64(2.0) // td
+        with pytest.raises(TypeError, match=msg):
+            np.uint8(9) // td
+        with pytest.raises(TypeError, match=msg):
+            # deprecated GH#19761, enforced GH#29797
+            np.int32(2.0) // td
+
+    def test_td_rfloordiv_timedeltalike_array(self):
+        # GH#18846
+        td = Timedelta(hours=3, minutes=3)
+        scalar = Timedelta(hours=3, minutes=4)
+
+        # Array-like others
+        assert td.__rfloordiv__(np.array(scalar.to_timedelta64())) == 1
+
+        res = td.__rfloordiv__(np.array([(3 * scalar).to_timedelta64()]))
+        expected = np.array([3], dtype=np.int64)
+        tm.assert_numpy_array_equal(res, expected)
+
+        arr = np.array([(10 * scalar).to_timedelta64(), np.timedelta64("NaT")])
+        res = td.__rfloordiv__(arr)
+        expected = np.array([10, np.nan])
+        tm.assert_numpy_array_equal(res, expected)
+
+    def test_td_rfloordiv_intarray(self):
+        # deprecated GH#19761, enforced GH#29797
+        ints = np.array([1349654400, 1349740800, 1349827200, 1349913600]) * 10**9
+
+        msg = "Invalid dtype"
+        with pytest.raises(TypeError, match=msg):
+            ints // Timedelta(1, unit="s")
+
+    def test_td_rfloordiv_numeric_series(self):
+        # GH#18846
+        td = Timedelta(hours=3, minutes=3)
+        ser = pd.Series([1], dtype=np.int64)
+        res = td.__rfloordiv__(ser)
+        assert res is NotImplemented
+
+        msg = "Invalid dtype"
+        with pytest.raises(TypeError, match=msg):
+            # Deprecated GH#19761, enforced GH#29797
+            ser // td
+
+    # ----------------------------------------------------------------
+    # Timedelta.__mod__, __rmod__
+
+    def test_mod_timedeltalike(self):
+        # GH#19365
+        td = Timedelta(hours=37)
+
+        # Timedelta-like others
+        result = td % Timedelta(hours=6)
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(hours=1)
+
+        result = td % timedelta(minutes=60)
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(0)
+
+        result = td % NaT
+        assert result is NaT
+
+    def test_mod_timedelta64_nat(self):
+        # GH#19365
+        td = Timedelta(hours=37)
+
+        result = td % np.timedelta64("NaT", "ns")
+        assert result is NaT
+
+    def test_mod_timedelta64(self):
+        # GH#19365
+        td = Timedelta(hours=37)
+
+        result = td % np.timedelta64(2, "h")
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(hours=1)
+
+    def test_mod_offset(self):
+        # GH#19365
+        td = Timedelta(hours=37)
+
+        result = td % offsets.Hour(5)
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(hours=2)
+
+    def test_mod_numeric(self):
+        # GH#19365
+        td = Timedelta(hours=37)
+
+        # Numeric Others
+        result = td % 2
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(0)
+
+        result = td % 1e12
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(minutes=3, seconds=20)
+
+        result = td % int(1e12)
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(minutes=3, seconds=20)
+
+    def test_mod_invalid(self):
+        # GH#19365
+        td = Timedelta(hours=37)
+        msg = "unsupported operand type"
+        with pytest.raises(TypeError, match=msg):
+            td % Timestamp("2018-01-22")
+
+        with pytest.raises(TypeError, match=msg):
+            td % []
+
+    def test_rmod_pytimedelta(self):
+        # GH#19365
+        td = Timedelta(minutes=3)
+
+        result = timedelta(minutes=4) % td
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(minutes=1)
+
+    def test_rmod_timedelta64(self):
+        # GH#19365
+        td = Timedelta(minutes=3)
+        result = np.timedelta64(5, "m") % td
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta(minutes=2)
+
+    def test_rmod_invalid(self):
+        # GH#19365
+        td = Timedelta(minutes=3)
+
+        msg = "unsupported operand"
+        with pytest.raises(TypeError, match=msg):
+            Timestamp("2018-01-22") % td
+
+        with pytest.raises(TypeError, match=msg):
+            15 % td
+
+        with pytest.raises(TypeError, match=msg):
+            16.0 % td
+
+        msg = "Invalid dtype int"
+        with pytest.raises(TypeError, match=msg):
+            np.array([22, 24]) % td
+
+    # ----------------------------------------------------------------
+    # Timedelta.__divmod__, __rdivmod__
+
+    def test_divmod_numeric(self):
+        # GH#19365
+        td = Timedelta(days=2, hours=6)
+
+        result = divmod(td, 53 * 3600 * 1e9)
+        assert result[0] == Timedelta(1, unit="ns")
+        assert isinstance(result[1], Timedelta)
+        assert result[1] == Timedelta(hours=1)
+
+        assert result
+        result = divmod(td, np.nan)
+        assert result[0] is NaT
+        assert result[1] is NaT
+
+    def test_divmod(self):
+        # GH#19365
+        td = Timedelta(days=2, hours=6)
+
+        result = divmod(td, timedelta(days=1))
+        assert result[0] == 2
+        assert isinstance(result[1], Timedelta)
+        assert result[1] == Timedelta(hours=6)
+
+        result = divmod(td, 54)
+        assert result[0] == Timedelta(hours=1)
+        assert isinstance(result[1], Timedelta)
+        assert result[1] == Timedelta(0)
+
+        result = divmod(td, NaT)
+        assert np.isnan(result[0])
+        assert result[1] is NaT
+
+    def test_divmod_offset(self):
+        # GH#19365
+        td = Timedelta(days=2, hours=6)
+
+        result = divmod(td, offsets.Hour(-4))
+        assert result[0] == -14
+        assert isinstance(result[1], Timedelta)
+        assert result[1] == Timedelta(hours=-2)
+
+    def test_divmod_invalid(self):
+        # GH#19365
+        td = Timedelta(days=2, hours=6)
+
+        msg = r"unsupported operand type\(s\) for //: 'Timedelta' and 'Timestamp'"
+        with pytest.raises(TypeError, match=msg):
+            divmod(td, Timestamp("2018-01-22"))
+
+    def test_rdivmod_pytimedelta(self):
+        # GH#19365
+        result = divmod(timedelta(days=2, hours=6), Timedelta(days=1))
+        assert result[0] == 2
+        assert isinstance(result[1], Timedelta)
+        assert result[1] == Timedelta(hours=6)
+
+    def test_rdivmod_offset(self):
+        result = divmod(offsets.Hour(54), Timedelta(hours=-4))
+        assert result[0] == -14
+        assert isinstance(result[1], Timedelta)
+        assert result[1] == Timedelta(hours=-2)
+
+    def test_rdivmod_invalid(self):
+        # GH#19365
+        td = Timedelta(minutes=3)
+        msg = "unsupported operand type"
+
+        with pytest.raises(TypeError, match=msg):
+            divmod(Timestamp("2018-01-22"), td)
+
+        with pytest.raises(TypeError, match=msg):
+            divmod(15, td)
+
+        with pytest.raises(TypeError, match=msg):
+            divmod(16.0, td)
+
+        msg = "Invalid dtype int"
+        with pytest.raises(TypeError, match=msg):
+            divmod(np.array([22, 24]), td)
+
+    # ----------------------------------------------------------------
+
+    @pytest.mark.parametrize(
+        "op", [operator.mul, ops.rmul, operator.truediv, ops.rdiv, ops.rsub]
+    )
+    @pytest.mark.parametrize(
+        "arr",
+        [
+            np.array([Timestamp("20130101 9:01"), Timestamp("20121230 9:02")]),
+            np.array([Timestamp("2021-11-09 09:54:00"), Timedelta("1D")]),
+        ],
+    )
+    def test_td_op_timedelta_timedeltalike_array(self, op, arr):
+        msg = "unsupported operand type|cannot use operands with types"
+        with pytest.raises(TypeError, match=msg):
+            op(arr, Timedelta("1D"))
+
+
+class TestTimedeltaComparison:
+    def test_compare_pytimedelta_bounds(self):
+        # GH#49021 don't overflow on comparison with very large pytimedeltas
+
+        for unit in ["ns", "us"]:
+            tdmax = Timedelta.max.as_unit(unit).max
+            tdmin = Timedelta.min.as_unit(unit).min
+
+            assert tdmax < timedelta.max
+            assert tdmax <= timedelta.max
+            assert not tdmax > timedelta.max
+            assert not tdmax >= timedelta.max
+            assert tdmax != timedelta.max
+            assert not tdmax == timedelta.max
+
+            assert tdmin > timedelta.min
+            assert tdmin >= timedelta.min
+            assert not tdmin < timedelta.min
+            assert not tdmin <= timedelta.min
+            assert tdmin != timedelta.min
+            assert not tdmin == timedelta.min
+
+        # But the "ms" and "s"-reso bounds extend pass pytimedelta
+        for unit in ["ms", "s"]:
+            tdmax = Timedelta.max.as_unit(unit).max
+            tdmin = Timedelta.min.as_unit(unit).min
+
+            assert tdmax > timedelta.max
+            assert tdmax >= timedelta.max
+            assert not tdmax < timedelta.max
+            assert not tdmax <= timedelta.max
+            assert tdmax != timedelta.max
+            assert not tdmax == timedelta.max
+
+            assert tdmin < timedelta.min
+            assert tdmin <= timedelta.min
+            assert not tdmin > timedelta.min
+            assert not tdmin >= timedelta.min
+            assert tdmin != timedelta.min
+            assert not tdmin == timedelta.min
+
+    def test_compare_pytimedelta_bounds2(self):
+        # a pytimedelta outside the microsecond bounds
+        pytd = timedelta(days=999999999, seconds=86399)
+        # NB: np.timedelta64(td, "s"") incorrectly overflows
+        td64 = np.timedelta64(pytd.days, "D") + np.timedelta64(pytd.seconds, "s")
+        td = Timedelta(td64)
+        assert td.days == pytd.days
+        assert td.seconds == pytd.seconds
+
+        assert td == pytd
+        assert not td != pytd
+        assert not td < pytd
+        assert not td > pytd
+        assert td <= pytd
+        assert td >= pytd
+
+        td2 = td - Timedelta(seconds=1).as_unit("s")
+        assert td2 != pytd
+        assert not td2 == pytd
+        assert td2 < pytd
+        assert td2 <= pytd
+        assert not td2 > pytd
+        assert not td2 >= pytd
+
+    def test_compare_tick(self, tick_classes):
+        cls = tick_classes
+
+        off = cls(4)
+        td = off.delta
+        assert isinstance(td, Timedelta)
+
+        assert td == off
+        assert not td != off
+        assert td <= off
+        assert td >= off
+        assert not td < off
+        assert not td > off
+
+        assert not td == 2 * off
+        assert td != 2 * off
+        assert td <= 2 * off
+        assert td < 2 * off
+        assert not td >= 2 * off
+        assert not td > 2 * off
+
+    def test_comparison_object_array(self):
+        # analogous to GH#15183
+        td = Timedelta("2 days")
+        other = Timedelta("3 hours")
+
+        arr = np.array([other, td], dtype=object)
+        res = arr == td
+        expected = np.array([False, True], dtype=bool)
+        assert (res == expected).all()
+
+        # 2D case
+        arr = np.array([[other, td], [td, other]], dtype=object)
+        res = arr != td
+        expected = np.array([[True, False], [False, True]], dtype=bool)
+        assert res.shape == expected.shape
+        assert (res == expected).all()
+
+    def test_compare_timedelta_ndarray(self):
+        # GH#11835
+        periods = [Timedelta("0 days 01:00:00"), Timedelta("0 days 01:00:00")]
+        arr = np.array(periods)
+        result = arr[0] > arr
+        expected = np.array([False, False])
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_compare_td64_ndarray(self):
+        # GG#33441
+        arr = np.arange(5).astype("timedelta64[ns]")
+        td = Timedelta(arr[1])
+
+        expected = np.array([False, True, False, False, False], dtype=bool)
+
+        result = td == arr
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = arr == td
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = td != arr
+        tm.assert_numpy_array_equal(result, ~expected)
+
+        result = arr != td
+        tm.assert_numpy_array_equal(result, ~expected)
+
+    def test_compare_custom_object(self):
+        """
+        Make sure non supported operations on Timedelta returns NonImplemented
+        and yields to other operand (GH#20829).
+        """
+
+        class CustomClass:
+            def __init__(self, cmp_result=None) -> None:
+                self.cmp_result = cmp_result
+
+            def generic_result(self):
+                if self.cmp_result is None:
+                    return NotImplemented
+                else:
+                    return self.cmp_result
+
+            def __eq__(self, other):
+                return self.generic_result()
+
+            def __gt__(self, other):
+                return self.generic_result()
+
+        t = Timedelta("1s")
+
+        assert t != "string"
+        assert t != 1
+        assert t != CustomClass()
+        assert t != CustomClass(cmp_result=False)
+
+        assert t < CustomClass(cmp_result=True)
+        assert not t < CustomClass(cmp_result=False)
+
+        assert t == CustomClass(cmp_result=True)
+
+    @pytest.mark.parametrize("val", ["string", 1])
+    def test_compare_unknown_type(self, val):
+        # GH#20829
+        t = Timedelta("1s")
+        msg = "not supported between instances of 'Timedelta' and '(int|str)'"
+        with pytest.raises(TypeError, match=msg):
+            t >= val
+        with pytest.raises(TypeError, match=msg):
+            t > val
+        with pytest.raises(TypeError, match=msg):
+            t <= val
+        with pytest.raises(TypeError, match=msg):
+            t < val
+
+
+def test_ops_notimplemented():
+    class Other:
+        pass
+
+    other = Other()
+
+    td = Timedelta("1 day")
+    assert td.__add__(other) is NotImplemented
+    assert td.__sub__(other) is NotImplemented
+    assert td.__truediv__(other) is NotImplemented
+    assert td.__mul__(other) is NotImplemented
+    assert td.__floordiv__(other) is NotImplemented
+
+
+def test_ops_error_str():
+    # GH#13624
+    td = Timedelta("1 day")
+
+    for left, right in [(td, "a"), ("a", td)]:
+        msg = "|".join(
+            [
+                "unsupported operand type",
+                r'can only concatenate str \(not "Timedelta"\) to str',
+                "must be str, not Timedelta",
+            ]
+        )
+        with pytest.raises(TypeError, match=msg):
+            left + right
+
+        msg = "not supported between instances of"
+        with pytest.raises(TypeError, match=msg):
+            left > right
+
+        assert not left == right  # pylint: disable=unneeded-not
+        assert left != right

videochat2/lib/python3.10/site-packages/pandas/tests/scalar/timedelta/test_constructors.py

@@ -0,0 +1,534 @@
+from datetime import timedelta
+from itertools import product
+
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs import OutOfBoundsTimedelta
+from pandas._libs.tslibs.dtypes import NpyDatetimeUnit
+
+from pandas import (
+    NaT,
+    Timedelta,
+    offsets,
+    to_timedelta,
+)
+
+
+def test_construct_with_weeks_unit_overflow():
+    # GH#47268 don't silently wrap around
+    with pytest.raises(OutOfBoundsTimedelta, match="without overflow"):
+        Timedelta(1000000000000000000, unit="W")
+
+    with pytest.raises(OutOfBoundsTimedelta, match="without overflow"):
+        Timedelta(1000000000000000000.0, unit="W")
+
+
+def test_construct_from_td64_with_unit():
+    # ignore the unit, as it may cause silently overflows leading to incorrect
+    #  results, and in non-overflow cases is irrelevant GH#46827
+    obj = np.timedelta64(123456789000000000, "h")
+
+    with pytest.raises(OutOfBoundsTimedelta, match="123456789000000000 hours"):
+        Timedelta(obj, unit="ps")
+
+    with pytest.raises(OutOfBoundsTimedelta, match="123456789000000000 hours"):
+        Timedelta(obj, unit="ns")
+
+    with pytest.raises(OutOfBoundsTimedelta, match="123456789000000000 hours"):
+        Timedelta(obj)
+
+
+def test_from_td64_retain_resolution():
+    # case where we retain millisecond resolution
+    obj = np.timedelta64(12345, "ms")
+
+    td = Timedelta(obj)
+    assert td._value == obj.view("i8")
+    assert td._creso == NpyDatetimeUnit.NPY_FR_ms.value
+
+    # Case where we cast to nearest-supported reso
+    obj2 = np.timedelta64(1234, "D")
+    td2 = Timedelta(obj2)
+    assert td2._creso == NpyDatetimeUnit.NPY_FR_s.value
+    assert td2 == obj2
+    assert td2.days == 1234
+
+    # Case that _would_ overflow if we didn't support non-nano
+    obj3 = np.timedelta64(1000000000000000000, "us")
+    td3 = Timedelta(obj3)
+    assert td3.total_seconds() == 1000000000000
+    assert td3._creso == NpyDatetimeUnit.NPY_FR_us.value
+
+
+def test_from_pytimedelta_us_reso():
+    # pytimedelta has microsecond resolution, so Timedelta(pytd) inherits that
+    td = timedelta(days=4, minutes=3)
+    result = Timedelta(td)
+    assert result.to_pytimedelta() == td
+    assert result._creso == NpyDatetimeUnit.NPY_FR_us.value
+
+
+def test_from_tick_reso():
+    tick = offsets.Nano()
+    assert Timedelta(tick)._creso == NpyDatetimeUnit.NPY_FR_ns.value
+
+    tick = offsets.Micro()
+    assert Timedelta(tick)._creso == NpyDatetimeUnit.NPY_FR_us.value
+
+    tick = offsets.Milli()
+    assert Timedelta(tick)._creso == NpyDatetimeUnit.NPY_FR_ms.value
+
+    tick = offsets.Second()
+    assert Timedelta(tick)._creso == NpyDatetimeUnit.NPY_FR_s.value
+
+    # everything above Second gets cast to the closest supported reso: second
+    tick = offsets.Minute()
+    assert Timedelta(tick)._creso == NpyDatetimeUnit.NPY_FR_s.value
+
+    tick = offsets.Hour()
+    assert Timedelta(tick)._creso == NpyDatetimeUnit.NPY_FR_s.value
+
+    tick = offsets.Day()
+    assert Timedelta(tick)._creso == NpyDatetimeUnit.NPY_FR_s.value
+
+
+def test_construction():
+    expected = np.timedelta64(10, "D").astype("m8[ns]").view("i8")
+    assert Timedelta(10, unit="d")._value == expected
+    assert Timedelta(10.0, unit="d")._value == expected
+    assert Timedelta("10 days")._value == expected
+    assert Timedelta(days=10)._value == expected
+    assert Timedelta(days=10.0)._value == expected
+
+    expected += np.timedelta64(10, "s").astype("m8[ns]").view("i8")
+    assert Timedelta("10 days 00:00:10")._value == expected
+    assert Timedelta(days=10, seconds=10)._value == expected
+    assert Timedelta(days=10, milliseconds=10 * 1000)._value == expected
+    assert Timedelta(days=10, microseconds=10 * 1000 * 1000)._value == expected
+
+    # rounding cases
+    assert Timedelta(82739999850000)._value == 82739999850000
+    assert "0 days 22:58:59.999850" in str(Timedelta(82739999850000))
+    assert Timedelta(123072001000000)._value == 123072001000000
+    assert "1 days 10:11:12.001" in str(Timedelta(123072001000000))
+
+    # string conversion with/without leading zero
+    # GH#9570
+    assert Timedelta("0:00:00") == timedelta(hours=0)
+    assert Timedelta("00:00:00") == timedelta(hours=0)
+    assert Timedelta("-1:00:00") == -timedelta(hours=1)
+    assert Timedelta("-01:00:00") == -timedelta(hours=1)
+
+    # more strings & abbrevs
+    # GH#8190
+    assert Timedelta("1 h") == timedelta(hours=1)
+    assert Timedelta("1 hour") == timedelta(hours=1)
+    assert Timedelta("1 hr") == timedelta(hours=1)
+    assert Timedelta("1 hours") == timedelta(hours=1)
+    assert Timedelta("-1 hours") == -timedelta(hours=1)
+    assert Timedelta("1 m") == timedelta(minutes=1)
+    assert Timedelta("1.5 m") == timedelta(seconds=90)
+    assert Timedelta("1 minute") == timedelta(minutes=1)
+    assert Timedelta("1 minutes") == timedelta(minutes=1)
+    assert Timedelta("1 s") == timedelta(seconds=1)
+    assert Timedelta("1 second") == timedelta(seconds=1)
+    assert Timedelta("1 seconds") == timedelta(seconds=1)
+    assert Timedelta("1 ms") == timedelta(milliseconds=1)
+    assert Timedelta("1 milli") == timedelta(milliseconds=1)
+    assert Timedelta("1 millisecond") == timedelta(milliseconds=1)
+    assert Timedelta("1 us") == timedelta(microseconds=1)
+    assert Timedelta("1 µs") == timedelta(microseconds=1)
+    assert Timedelta("1 micros") == timedelta(microseconds=1)
+    assert Timedelta("1 microsecond") == timedelta(microseconds=1)
+    assert Timedelta("1.5 microsecond") == Timedelta("00:00:00.000001500")
+    assert Timedelta("1 ns") == Timedelta("00:00:00.000000001")
+    assert Timedelta("1 nano") == Timedelta("00:00:00.000000001")
+    assert Timedelta("1 nanosecond") == Timedelta("00:00:00.000000001")
+
+    # combos
+    assert Timedelta("10 days 1 hour") == timedelta(days=10, hours=1)
+    assert Timedelta("10 days 1 h") == timedelta(days=10, hours=1)
+    assert Timedelta("10 days 1 h 1m 1s") == timedelta(
+        days=10, hours=1, minutes=1, seconds=1
+    )
+    assert Timedelta("-10 days 1 h 1m 1s") == -timedelta(
+        days=10, hours=1, minutes=1, seconds=1
+    )
+    assert Timedelta("-10 days 1 h 1m 1s") == -timedelta(
+        days=10, hours=1, minutes=1, seconds=1
+    )
+    assert Timedelta("-10 days 1 h 1m 1s 3us") == -timedelta(
+        days=10, hours=1, minutes=1, seconds=1, microseconds=3
+    )
+    assert Timedelta("-10 days 1 h 1.5m 1s 3us") == -timedelta(
+        days=10, hours=1, minutes=1, seconds=31, microseconds=3
+    )
+
+    # Currently invalid as it has a - on the hh:mm:dd part
+    # (only allowed on the days)
+    msg = "only leading negative signs are allowed"
+    with pytest.raises(ValueError, match=msg):
+        Timedelta("-10 days -1 h 1.5m 1s 3us")
+
+    # only leading neg signs are allowed
+    with pytest.raises(ValueError, match=msg):
+        Timedelta("10 days -1 h 1.5m 1s 3us")
+
+    # no units specified
+    msg = "no units specified"
+    with pytest.raises(ValueError, match=msg):
+        Timedelta("3.1415")
+
+    # invalid construction
+    msg = "cannot construct a Timedelta"
+    with pytest.raises(ValueError, match=msg):
+        Timedelta()
+
+    msg = "unit abbreviation w/o a number"
+    with pytest.raises(ValueError, match=msg):
+        Timedelta("foo")
+
+    msg = (
+        "cannot construct a Timedelta from "
+        "the passed arguments, allowed keywords are "
+    )
+    with pytest.raises(ValueError, match=msg):
+        Timedelta(day=10)
+
+    # floats
+    expected = np.timedelta64(10, "s").astype("m8[ns]").view("i8") + np.timedelta64(
+        500, "ms"
+    ).astype("m8[ns]").view("i8")
+    assert Timedelta(10.5, unit="s")._value == expected
+
+    # offset
+    assert to_timedelta(offsets.Hour(2)) == Timedelta(hours=2)
+    assert Timedelta(offsets.Hour(2)) == Timedelta(hours=2)
+    assert Timedelta(offsets.Second(2)) == Timedelta(seconds=2)
+
+    # GH#11995: unicode
+    expected = Timedelta("1H")
+    result = Timedelta("1H")
+    assert result == expected
+    assert to_timedelta(offsets.Hour(2)) == Timedelta("0 days, 02:00:00")
+
+    msg = "unit abbreviation w/o a number"
+    with pytest.raises(ValueError, match=msg):
+        Timedelta("foo bar")
+
+
+@pytest.mark.parametrize(
+    "item",
+    list(
+        {
+            "days": "D",
+            "seconds": "s",
+            "microseconds": "us",
+            "milliseconds": "ms",
+            "minutes": "m",
+            "hours": "h",
+            "weeks": "W",
+        }.items()
+    ),
+)
+@pytest.mark.parametrize(
+    "npdtype", [np.int64, np.int32, np.int16, np.float64, np.float32, np.float16]
+)
+def test_td_construction_with_np_dtypes(npdtype, item):
+    # GH#8757: test construction with np dtypes
+    pykwarg, npkwarg = item
+    expected = np.timedelta64(1, npkwarg).astype("m8[ns]").view("i8")
+    assert Timedelta(**{pykwarg: npdtype(1)})._value == expected
+
+
+@pytest.mark.parametrize(
+    "val",
+    [
+        "1s",
+        "-1s",
+        "1us",
+        "-1us",
+        "1 day",
+        "-1 day",
+        "-23:59:59.999999",
+        "-1 days +23:59:59.999999",
+        "-1ns",
+        "1ns",
+        "-23:59:59.999999999",
+    ],
+)
+def test_td_from_repr_roundtrip(val):
+    # round-trip both for string and value
+    td = Timedelta(val)
+    assert Timedelta(td._value) == td
+
+    assert Timedelta(str(td)) == td
+    assert Timedelta(td._repr_base(format="all")) == td
+    assert Timedelta(td._repr_base()) == td
+
+
+def test_overflow_on_construction():
+    # GH#3374
+    value = Timedelta("1day")._value * 20169940
+    msg = "Cannot cast 1742682816000000000000 from ns to 'ns' without overflow"
+    with pytest.raises(OutOfBoundsTimedelta, match=msg):
+        Timedelta(value)
+
+    # xref GH#17637
+    msg = "Cannot cast 139993 from D to 'ns' without overflow"
+    with pytest.raises(OutOfBoundsTimedelta, match=msg):
+        Timedelta(7 * 19999, unit="D")
+
+    # used to overflow before non-ns support
+    td = Timedelta(timedelta(days=13 * 19999))
+    assert td._creso == NpyDatetimeUnit.NPY_FR_us.value
+    assert td.days == 13 * 19999
+
+
+@pytest.mark.parametrize(
+    "val, unit",
+    [
+        (3508, "M"),
+        (15251, "W"),  # 1
+        (106752, "D"),  # change from previous:
+        (2562048, "h"),  # 0 hours
+        (153722868, "m"),  # 13 minutes
+        (9223372037, "s"),  # 44 seconds
+    ],
+)
+def test_construction_out_of_bounds_td64ns(val, unit):
+    # TODO: parametrize over units just above/below the implementation bounds
+    #  once GH#38964 is resolved
+
+    # Timedelta.max is just under 106752 days
+    td64 = np.timedelta64(val, unit)
+    assert td64.astype("m8[ns]").view("i8") < 0  # i.e. naive astype will be wrong
+
+    td = Timedelta(td64)
+    if unit != "M":
+        # with unit="M" the conversion to "s" is poorly defined
+        #  (and numpy issues DeprecationWarning)
+        assert td.asm8 == td64
+    assert td.asm8.dtype == "m8[s]"
+    msg = r"Cannot cast 1067\d\d days .* to unit='ns' without overflow"
+    with pytest.raises(OutOfBoundsTimedelta, match=msg):
+        td.as_unit("ns")
+
+    # But just back in bounds and we are OK
+    assert Timedelta(td64 - 1) == td64 - 1
+
+    td64 *= -1
+    assert td64.astype("m8[ns]").view("i8") > 0  # i.e. naive astype will be wrong
+
+    td2 = Timedelta(td64)
+    msg = r"Cannot cast -1067\d\d days .* to unit='ns' without overflow"
+    with pytest.raises(OutOfBoundsTimedelta, match=msg):
+        td2.as_unit("ns")
+
+    # But just back in bounds and we are OK
+    assert Timedelta(td64 + 1) == td64 + 1
+
+
+@pytest.mark.parametrize(
+    "val, unit",
+    [
+        (3508 * 10**9, "M"),
+        (15251 * 10**9, "W"),
+        (106752 * 10**9, "D"),
+        (2562048 * 10**9, "h"),
+        (153722868 * 10**9, "m"),
+    ],
+)
+def test_construction_out_of_bounds_td64s(val, unit):
+    td64 = np.timedelta64(val, unit)
+    with pytest.raises(OutOfBoundsTimedelta, match=str(td64)):
+        Timedelta(td64)
+
+    # But just back in bounds and we are OK
+    assert Timedelta(td64 - 10**9) == td64 - 10**9
+
+
+@pytest.mark.parametrize(
+    "fmt,exp",
+    [
+        (
+            "P6DT0H50M3.010010012S",
+            Timedelta(
+                days=6,
+                minutes=50,
+                seconds=3,
+                milliseconds=10,
+                microseconds=10,
+                nanoseconds=12,
+            ),
+        ),
+        (
+            "P-6DT0H50M3.010010012S",
+            Timedelta(
+                days=-6,
+                minutes=50,
+                seconds=3,
+                milliseconds=10,
+                microseconds=10,
+                nanoseconds=12,
+            ),
+        ),
+        ("P4DT12H30M5S", Timedelta(days=4, hours=12, minutes=30, seconds=5)),
+        ("P0DT0H0M0.000000123S", Timedelta(nanoseconds=123)),
+        ("P0DT0H0M0.00001S", Timedelta(microseconds=10)),
+        ("P0DT0H0M0.001S", Timedelta(milliseconds=1)),
+        ("P0DT0H1M0S", Timedelta(minutes=1)),
+        ("P1DT25H61M61S", Timedelta(days=1, hours=25, minutes=61, seconds=61)),
+        ("PT1S", Timedelta(seconds=1)),
+        ("PT0S", Timedelta(seconds=0)),
+        ("P1WT0S", Timedelta(days=7, seconds=0)),
+        ("P1D", Timedelta(days=1)),
+        ("P1DT1H", Timedelta(days=1, hours=1)),
+        ("P1W", Timedelta(days=7)),
+        ("PT300S", Timedelta(seconds=300)),
+        ("P1DT0H0M00000000000S", Timedelta(days=1)),
+        ("PT-6H3M", Timedelta(hours=-6, minutes=3)),
+        ("-PT6H3M", Timedelta(hours=-6, minutes=-3)),
+        ("-PT-6H+3M", Timedelta(hours=6, minutes=-3)),
+    ],
+)
+def test_iso_constructor(fmt, exp):
+    assert Timedelta(fmt) == exp
+
+
+@pytest.mark.parametrize(
+    "fmt",
+    [
+        "PPPPPPPPPPPP",
+        "PDTHMS",
+        "P0DT999H999M999S",
+        "P1DT0H0M0.0000000000000S",
+        "P1DT0H0M0.S",
+        "P",
+        "-P",
+    ],
+)
+def test_iso_constructor_raises(fmt):
+    msg = f"Invalid ISO 8601 Duration format - {fmt}"
+    with pytest.raises(ValueError, match=msg):
+        Timedelta(fmt)
+
+
+@pytest.mark.parametrize(
+    "constructed_td, conversion",
+    [
+        (Timedelta(nanoseconds=100), "100ns"),
+        (
+            Timedelta(
+                days=1,
+                hours=1,
+                minutes=1,
+                weeks=1,
+                seconds=1,
+                milliseconds=1,
+                microseconds=1,
+                nanoseconds=1,
+            ),
+            694861001001001,
+        ),
+        (Timedelta(microseconds=1) + Timedelta(nanoseconds=1), "1us1ns"),
+        (Timedelta(microseconds=1) - Timedelta(nanoseconds=1), "999ns"),
+        (Timedelta(microseconds=1) + 5 * Timedelta(nanoseconds=-2), "990ns"),
+    ],
+)
+def test_td_constructor_on_nanoseconds(constructed_td, conversion):
+    # GH#9273
+    assert constructed_td == Timedelta(conversion)
+
+
+def test_td_constructor_value_error():
+    msg = "Invalid type <class 'str'>. Must be int or float."
+    with pytest.raises(TypeError, match=msg):
+        Timedelta(nanoseconds="abc")
+
+
+def test_timedelta_constructor_identity():
+    # Test for #30543
+    expected = Timedelta(np.timedelta64(1, "s"))
+    result = Timedelta(expected)
+    assert result is expected
+
+
+def test_timedelta_pass_td_and_kwargs_raises():
+    # don't silently ignore the kwargs GH#48898
+    td = Timedelta(days=1)
+    msg = (
+        "Cannot pass both a Timedelta input and timedelta keyword arguments, "
+        r"got \['days'\]"
+    )
+    with pytest.raises(ValueError, match=msg):
+        Timedelta(td, days=2)
+
+
+@pytest.mark.parametrize(
+    "constructor, value, unit, expectation",
+    [
+        (Timedelta, "10s", "ms", (ValueError, "unit must not be specified")),
+        (to_timedelta, "10s", "ms", (ValueError, "unit must not be specified")),
+        (to_timedelta, ["1", 2, 3], "s", (ValueError, "unit must not be specified")),
+    ],
+)
+def test_string_with_unit(constructor, value, unit, expectation):
+    exp, match = expectation
+    with pytest.raises(exp, match=match):
+        _ = constructor(value, unit=unit)
+
+
+@pytest.mark.parametrize(
+    "value",
+    [
+        "".join(elements)
+        for repetition in (1, 2)
+        for elements in product("+-, ", repeat=repetition)
+    ],
+)
+def test_string_without_numbers(value):
+    # GH39710 Timedelta input string with only symbols and no digits raises an error
+    msg = (
+        "symbols w/o a number"
+        if value != "--"
+        else "only leading negative signs are allowed"
+    )
+    with pytest.raises(ValueError, match=msg):
+        Timedelta(value)
+
+
+def test_timedelta_new_npnat():
+    # GH#48898
+    nat = np.timedelta64("NaT", "h")
+    assert Timedelta(nat) is NaT
+
+
+def test_subclass_respected():
+    # GH#49579
+    class MyCustomTimedelta(Timedelta):
+        pass
+
+    td = MyCustomTimedelta("1 minute")
+    assert isinstance(td, MyCustomTimedelta)
+
+
+def test_non_nano_value():
+    # https://github.com/pandas-dev/pandas/issues/49076
+    result = Timedelta(10, unit="D").as_unit("s").value
+    # `.value` shows nanoseconds, even though unit is 's'
+    assert result == 864000000000000
+
+    # out-of-nanoseconds-bounds `.value` raises informative message
+    msg = (
+        r"Cannot convert Timedelta to nanoseconds without overflow. "
+        r"Use `.asm8.view\('i8'\)` to cast represent Timedelta in its "
+        r"own unit \(here, s\).$"
+    )
+    td = Timedelta(1_000, "D").as_unit("s") * 1_000
+    with pytest.raises(OverflowError, match=msg):
+        td.value
+    # check that the suggested workaround actually works
+    result = td.asm8.view("i8")
+    assert result == 86400000000

videochat2/lib/python3.10/site-packages/pandas/tests/scalar/timedelta/test_formats.py

@@ -0,0 +1,44 @@
+import pytest
+
+from pandas import Timedelta
+
+
+@pytest.mark.parametrize(
+    "td, expected_repr",
+    [
+        (Timedelta(10, unit="d"), "Timedelta('10 days 00:00:00')"),
+        (Timedelta(10, unit="s"), "Timedelta('0 days 00:00:10')"),
+        (Timedelta(10, unit="ms"), "Timedelta('0 days 00:00:00.010000')"),
+        (Timedelta(-10, unit="ms"), "Timedelta('-1 days +23:59:59.990000')"),
+    ],
+)
+def test_repr(td, expected_repr):
+    assert repr(td) == expected_repr
+
+
+@pytest.mark.parametrize(
+    "td, expected_iso",
+    [
+        (
+            Timedelta(
+                days=6,
+                minutes=50,
+                seconds=3,
+                milliseconds=10,
+                microseconds=10,
+                nanoseconds=12,
+            ),
+            "P6DT0H50M3.010010012S",
+        ),
+        (Timedelta(days=4, hours=12, minutes=30, seconds=5), "P4DT12H30M5S"),
+        (Timedelta(nanoseconds=123), "P0DT0H0M0.000000123S"),
+        # trim nano
+        (Timedelta(microseconds=10), "P0DT0H0M0.00001S"),
+        # trim micro
+        (Timedelta(milliseconds=1), "P0DT0H0M0.001S"),
+        # don't strip every 0
+        (Timedelta(minutes=1), "P0DT0H1M0S"),
+    ],
+)
+def test_isoformat(td, expected_iso):
+    assert td.isoformat() == expected_iso

videochat2/lib/python3.10/site-packages/pandas/tests/scalar/timedelta/test_timedelta.py

@@ -0,0 +1,962 @@
+""" test the scalar Timedelta """
+from datetime import timedelta
+
+from hypothesis import (
+    given,
+    strategies as st,
+)
+import numpy as np
+import pytest
+
+from pandas._libs import lib
+from pandas._libs.tslibs import (
+    NaT,
+    iNaT,
+)
+from pandas._libs.tslibs.dtypes import NpyDatetimeUnit
+from pandas.errors import OutOfBoundsTimedelta
+
+import pandas as pd
+from pandas import (
+    Timedelta,
+    TimedeltaIndex,
+    to_timedelta,
+)
+import pandas._testing as tm
+
+
+class TestAsUnit:
+    def test_as_unit(self):
+        td = Timedelta(days=1)
+
+        assert td.as_unit("ns") is td
+
+        res = td.as_unit("us")
+        assert res._value == td._value // 1000
+        assert res._creso == NpyDatetimeUnit.NPY_FR_us.value
+
+        rt = res.as_unit("ns")
+        assert rt._value == td._value
+        assert rt._creso == td._creso
+
+        res = td.as_unit("ms")
+        assert res._value == td._value // 1_000_000
+        assert res._creso == NpyDatetimeUnit.NPY_FR_ms.value
+
+        rt = res.as_unit("ns")
+        assert rt._value == td._value
+        assert rt._creso == td._creso
+
+        res = td.as_unit("s")
+        assert res._value == td._value // 1_000_000_000
+        assert res._creso == NpyDatetimeUnit.NPY_FR_s.value
+
+        rt = res.as_unit("ns")
+        assert rt._value == td._value
+        assert rt._creso == td._creso
+
+    def test_as_unit_overflows(self):
+        # microsecond that would be just out of bounds for nano
+        us = 9223372800000000
+        td = Timedelta._from_value_and_reso(us, NpyDatetimeUnit.NPY_FR_us.value)
+
+        msg = "Cannot cast 106752 days 00:00:00 to unit='ns' without overflow"
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
+            td.as_unit("ns")
+
+        res = td.as_unit("ms")
+        assert res._value == us // 1000
+        assert res._creso == NpyDatetimeUnit.NPY_FR_ms.value
+
+    def test_as_unit_rounding(self):
+        td = Timedelta(microseconds=1500)
+        res = td.as_unit("ms")
+
+        expected = Timedelta(milliseconds=1)
+        assert res == expected
+
+        assert res._creso == NpyDatetimeUnit.NPY_FR_ms.value
+        assert res._value == 1
+
+        with pytest.raises(ValueError, match="Cannot losslessly convert units"):
+            td.as_unit("ms", round_ok=False)
+
+    def test_as_unit_non_nano(self):
+        # case where we are going neither to nor from nano
+        td = Timedelta(days=1).as_unit("ms")
+        assert td.days == 1
+        assert td._value == 86_400_000
+        assert td.components.days == 1
+        assert td._d == 1
+        assert td.total_seconds() == 86400
+
+        res = td.as_unit("us")
+        assert res._value == 86_400_000_000
+        assert res.components.days == 1
+        assert res.components.hours == 0
+        assert res._d == 1
+        assert res._h == 0
+        assert res.total_seconds() == 86400
+
+
+class TestNonNano:
+    @pytest.fixture(params=["s", "ms", "us"])
+    def unit_str(self, request):
+        return request.param
+
+    @pytest.fixture
+    def unit(self, unit_str):
+        # 7, 8, 9 correspond to second, millisecond, and microsecond, respectively
+        attr = f"NPY_FR_{unit_str}"
+        return getattr(NpyDatetimeUnit, attr).value
+
+    @pytest.fixture
+    def val(self, unit):
+        # microsecond that would be just out of bounds for nano
+        us = 9223372800000000
+        if unit == NpyDatetimeUnit.NPY_FR_us.value:
+            value = us
+        elif unit == NpyDatetimeUnit.NPY_FR_ms.value:
+            value = us // 1000
+        else:
+            value = us // 1_000_000
+        return value
+
+    @pytest.fixture
+    def td(self, unit, val):
+        return Timedelta._from_value_and_reso(val, unit)
+
+    def test_from_value_and_reso(self, unit, val):
+        # Just checking that the fixture is giving us what we asked for
+        td = Timedelta._from_value_and_reso(val, unit)
+        assert td._value == val
+        assert td._creso == unit
+        assert td.days == 106752
+
+    def test_unary_non_nano(self, td, unit):
+        assert abs(td)._creso == unit
+        assert (-td)._creso == unit
+        assert (+td)._creso == unit
+
+    def test_sub_preserves_reso(self, td, unit):
+        res = td - td
+        expected = Timedelta._from_value_and_reso(0, unit)
+        assert res == expected
+        assert res._creso == unit
+
+    def test_mul_preserves_reso(self, td, unit):
+        # The td fixture should always be far from the implementation
+        #  bound, so doubling does not risk overflow.
+        res = td * 2
+        assert res._value == td._value * 2
+        assert res._creso == unit
+
+    def test_cmp_cross_reso(self, td):
+        # numpy gets this wrong because of silent overflow
+        other = Timedelta(days=106751, unit="ns")
+        assert other < td
+        assert td > other
+        assert not other == td
+        assert td != other
+
+    def test_to_pytimedelta(self, td):
+        res = td.to_pytimedelta()
+        expected = timedelta(days=106752)
+        assert type(res) is timedelta
+        assert res == expected
+
+    def test_to_timedelta64(self, td, unit):
+        for res in [td.to_timedelta64(), td.to_numpy(), td.asm8]:
+            assert isinstance(res, np.timedelta64)
+            assert res.view("i8") == td._value
+            if unit == NpyDatetimeUnit.NPY_FR_s.value:
+                assert res.dtype == "m8[s]"
+            elif unit == NpyDatetimeUnit.NPY_FR_ms.value:
+                assert res.dtype == "m8[ms]"
+            elif unit == NpyDatetimeUnit.NPY_FR_us.value:
+                assert res.dtype == "m8[us]"
+
+    def test_truediv_timedeltalike(self, td):
+        assert td / td == 1
+        assert (2.5 * td) / td == 2.5
+
+        other = Timedelta(td._value)
+        msg = "Cannot cast 106752 days 00:00:00 to unit='ns' without overflow."
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
+            td / other
+
+        # Timedelta(other.to_pytimedelta()) has microsecond resolution,
+        #  so the division doesn't require casting all the way to nanos,
+        #  so succeeds
+        res = other.to_pytimedelta() / td
+        expected = other.to_pytimedelta() / td.to_pytimedelta()
+        assert res == expected
+
+        # if there's no overflow, we cast to the higher reso
+        left = Timedelta._from_value_and_reso(50, NpyDatetimeUnit.NPY_FR_us.value)
+        right = Timedelta._from_value_and_reso(50, NpyDatetimeUnit.NPY_FR_ms.value)
+        result = left / right
+        assert result == 0.001
+
+        result = right / left
+        assert result == 1000
+
+    def test_truediv_numeric(self, td):
+        assert td / np.nan is NaT
+
+        res = td / 2
+        assert res._value == td._value / 2
+        assert res._creso == td._creso
+
+        res = td / 2.0
+        assert res._value == td._value / 2
+        assert res._creso == td._creso
+
+    def test_floordiv_timedeltalike(self, td):
+        assert td // td == 1
+        assert (2.5 * td) // td == 2
+
+        other = Timedelta(td._value)
+        msg = "Cannot cast 106752 days 00:00:00 to unit='ns' without overflow"
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
+            td // other
+
+        # Timedelta(other.to_pytimedelta()) has microsecond resolution,
+        #  so the floordiv doesn't require casting all the way to nanos,
+        #  so succeeds
+        res = other.to_pytimedelta() // td
+        assert res == 0
+
+        # if there's no overflow, we cast to the higher reso
+        left = Timedelta._from_value_and_reso(50050, NpyDatetimeUnit.NPY_FR_us.value)
+        right = Timedelta._from_value_and_reso(50, NpyDatetimeUnit.NPY_FR_ms.value)
+        result = left // right
+        assert result == 1
+        result = right // left
+        assert result == 0
+
+    def test_floordiv_numeric(self, td):
+        assert td // np.nan is NaT
+
+        res = td // 2
+        assert res._value == td._value // 2
+        assert res._creso == td._creso
+
+        res = td // 2.0
+        assert res._value == td._value // 2
+        assert res._creso == td._creso
+
+        assert td // np.array(np.nan) is NaT
+
+        res = td // np.array(2)
+        assert res._value == td._value // 2
+        assert res._creso == td._creso
+
+        res = td // np.array(2.0)
+        assert res._value == td._value // 2
+        assert res._creso == td._creso
+
+    def test_addsub_mismatched_reso(self, td):
+        # need to cast to since td is out of bounds for ns, so
+        #  so we would raise OverflowError without casting
+        other = Timedelta(days=1).as_unit("us")
+
+        # td is out of bounds for ns
+        result = td + other
+        assert result._creso == other._creso
+        assert result.days == td.days + 1
+
+        result = other + td
+        assert result._creso == other._creso
+        assert result.days == td.days + 1
+
+        result = td - other
+        assert result._creso == other._creso
+        assert result.days == td.days - 1
+
+        result = other - td
+        assert result._creso == other._creso
+        assert result.days == 1 - td.days
+
+        other2 = Timedelta(500)
+        msg = "Cannot cast 106752 days 00:00:00 to unit='ns' without overflow"
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
+            td + other2
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
+            other2 + td
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
+            td - other2
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
+            other2 - td
+
+    def test_min(self, td):
+        assert td.min <= td
+        assert td.min._creso == td._creso
+        assert td.min._value == NaT._value + 1
+
+    def test_max(self, td):
+        assert td.max >= td
+        assert td.max._creso == td._creso
+        assert td.max._value == np.iinfo(np.int64).max
+
+    def test_resolution(self, td):
+        expected = Timedelta._from_value_and_reso(1, td._creso)
+        result = td.resolution
+        assert result == expected
+        assert result._creso == expected._creso
+
+
+def test_timedelta_class_min_max_resolution():
+    # when accessed on the class (as opposed to an instance), we default
+    #  to nanoseconds
+    assert Timedelta.min == Timedelta(NaT._value + 1)
+    assert Timedelta.min._creso == NpyDatetimeUnit.NPY_FR_ns.value
+
+    assert Timedelta.max == Timedelta(np.iinfo(np.int64).max)
+    assert Timedelta.max._creso == NpyDatetimeUnit.NPY_FR_ns.value
+
+    assert Timedelta.resolution == Timedelta(1)
+    assert Timedelta.resolution._creso == NpyDatetimeUnit.NPY_FR_ns.value
+
+
+class TestTimedeltaUnaryOps:
+    def test_invert(self):
+        td = Timedelta(10, unit="d")
+
+        msg = "bad operand type for unary ~"
+        with pytest.raises(TypeError, match=msg):
+            ~td
+
+        # check this matches pytimedelta and timedelta64
+        with pytest.raises(TypeError, match=msg):
+            ~(td.to_pytimedelta())
+
+        umsg = "ufunc 'invert' not supported for the input types"
+        with pytest.raises(TypeError, match=umsg):
+            ~(td.to_timedelta64())
+
+    def test_unary_ops(self):
+        td = Timedelta(10, unit="d")
+
+        # __neg__, __pos__
+        assert -td == Timedelta(-10, unit="d")
+        assert -td == Timedelta("-10d")
+        assert +td == Timedelta(10, unit="d")
+
+        # __abs__, __abs__(__neg__)
+        assert abs(td) == td
+        assert abs(-td) == td
+        assert abs(-td) == Timedelta("10d")
+
+
+class TestTimedeltas:
+    @pytest.mark.parametrize(
+        "unit, value, expected",
+        [
+            ("us", 9.999, 9999),
+            ("ms", 9.999999, 9999999),
+            ("s", 9.999999999, 9999999999),
+        ],
+    )
+    def test_rounding_on_int_unit_construction(self, unit, value, expected):
+        # GH 12690
+        result = Timedelta(value, unit=unit)
+        assert result._value == expected
+        result = Timedelta(str(value) + unit)
+        assert result._value == expected
+
+    def test_total_seconds_scalar(self):
+        # see gh-10939
+        rng = Timedelta("1 days, 10:11:12.100123456")
+        expt = 1 * 86400 + 10 * 3600 + 11 * 60 + 12 + 100123456.0 / 1e9
+        tm.assert_almost_equal(rng.total_seconds(), expt)
+
+        rng = Timedelta(np.nan)
+        assert np.isnan(rng.total_seconds())
+
+    def test_conversion(self):
+        for td in [Timedelta(10, unit="d"), Timedelta("1 days, 10:11:12.012345")]:
+            pydt = td.to_pytimedelta()
+            assert td == Timedelta(pydt)
+            assert td == pydt
+            assert isinstance(pydt, timedelta) and not isinstance(pydt, Timedelta)
+
+            assert td == np.timedelta64(td._value, "ns")
+            td64 = td.to_timedelta64()
+
+            assert td64 == np.timedelta64(td._value, "ns")
+            assert td == td64
+
+            assert isinstance(td64, np.timedelta64)
+
+        # this is NOT equal and cannot be roundtripped (because of the nanos)
+        td = Timedelta("1 days, 10:11:12.012345678")
+        assert td != td.to_pytimedelta()
+
+    def test_fields(self):
+        def check(value):
+            # that we are int
+            assert isinstance(value, int)
+
+        # compat to datetime.timedelta
+        rng = to_timedelta("1 days, 10:11:12")
+        assert rng.days == 1
+        assert rng.seconds == 10 * 3600 + 11 * 60 + 12
+        assert rng.microseconds == 0
+        assert rng.nanoseconds == 0
+
+        msg = "'Timedelta' object has no attribute '{}'"
+        with pytest.raises(AttributeError, match=msg.format("hours")):
+            rng.hours
+        with pytest.raises(AttributeError, match=msg.format("minutes")):
+            rng.minutes
+        with pytest.raises(AttributeError, match=msg.format("milliseconds")):
+            rng.milliseconds
+
+        # GH 10050
+        check(rng.days)
+        check(rng.seconds)
+        check(rng.microseconds)
+        check(rng.nanoseconds)
+
+        td = Timedelta("-1 days, 10:11:12")
+        assert abs(td) == Timedelta("13:48:48")
+        assert str(td) == "-1 days +10:11:12"
+        assert -td == Timedelta("0 days 13:48:48")
+        assert -Timedelta("-1 days, 10:11:12")._value == 49728000000000
+        assert Timedelta("-1 days, 10:11:12")._value == -49728000000000
+
+        rng = to_timedelta("-1 days, 10:11:12.100123456")
+        assert rng.days == -1
+        assert rng.seconds == 10 * 3600 + 11 * 60 + 12
+        assert rng.microseconds == 100 * 1000 + 123
+        assert rng.nanoseconds == 456
+        msg = "'Timedelta' object has no attribute '{}'"
+        with pytest.raises(AttributeError, match=msg.format("hours")):
+            rng.hours
+        with pytest.raises(AttributeError, match=msg.format("minutes")):
+            rng.minutes
+        with pytest.raises(AttributeError, match=msg.format("milliseconds")):
+            rng.milliseconds
+
+        # components
+        tup = to_timedelta(-1, "us").components
+        assert tup.days == -1
+        assert tup.hours == 23
+        assert tup.minutes == 59
+        assert tup.seconds == 59
+        assert tup.milliseconds == 999
+        assert tup.microseconds == 999
+        assert tup.nanoseconds == 0
+
+        # GH 10050
+        check(tup.days)
+        check(tup.hours)
+        check(tup.minutes)
+        check(tup.seconds)
+        check(tup.milliseconds)
+        check(tup.microseconds)
+        check(tup.nanoseconds)
+
+        tup = Timedelta("-1 days 1 us").components
+        assert tup.days == -2
+        assert tup.hours == 23
+        assert tup.minutes == 59
+        assert tup.seconds == 59
+        assert tup.milliseconds == 999
+        assert tup.microseconds == 999
+        assert tup.nanoseconds == 0
+
+    def test_iso_conversion(self):
+        # GH #21877
+        expected = Timedelta(1, unit="s")
+        assert to_timedelta("P0DT0H0M1S") == expected
+
+    def test_nat_converters(self):
+        result = to_timedelta("nat").to_numpy()
+        assert result.dtype.kind == "M"
+        assert result.astype("int64") == iNaT
+
+        result = to_timedelta("nan").to_numpy()
+        assert result.dtype.kind == "M"
+        assert result.astype("int64") == iNaT
+
+    @pytest.mark.parametrize(
+        "unit, np_unit",
+        [(value, "W") for value in ["W", "w"]]
+        + [(value, "D") for value in ["D", "d", "days", "day", "Days", "Day"]]
+        + [
+            (value, "m")
+            for value in [
+                "m",
+                "minute",
+                "min",
+                "minutes",
+                "t",
+                "Minute",
+                "Min",
+                "Minutes",
+                "T",
+            ]
+        ]
+        + [
+            (value, "s")
+            for value in [
+                "s",
+                "seconds",
+                "sec",
+                "second",
+                "S",
+                "Seconds",
+                "Sec",
+                "Second",
+            ]
+        ]
+        + [
+            (value, "ms")
+            for value in [
+                "ms",
+                "milliseconds",
+                "millisecond",
+                "milli",
+                "millis",
+                "l",
+                "MS",
+                "Milliseconds",
+                "Millisecond",
+                "Milli",
+                "Millis",
+                "L",
+            ]
+        ]
+        + [
+            (value, "us")
+            for value in [
+                "us",
+                "microseconds",
+                "microsecond",
+                "micro",
+                "micros",
+                "u",
+                "US",
+                "Microseconds",
+                "Microsecond",
+                "Micro",
+                "Micros",
+                "U",
+            ]
+        ]
+        + [
+            (value, "ns")
+            for value in [
+                "ns",
+                "nanoseconds",
+                "nanosecond",
+                "nano",
+                "nanos",
+                "n",
+                "NS",
+                "Nanoseconds",
+                "Nanosecond",
+                "Nano",
+                "Nanos",
+                "N",
+            ]
+        ],
+    )
+    @pytest.mark.parametrize("wrapper", [np.array, list, pd.Index])
+    def test_unit_parser(self, unit, np_unit, wrapper):
+        # validate all units, GH 6855, GH 21762
+        # array-likes
+        expected = TimedeltaIndex(
+            [np.timedelta64(i, np_unit) for i in np.arange(5).tolist()],
+            dtype="m8[ns]",
+        )
+        # TODO(2.0): the desired output dtype may have non-nano resolution
+        result = to_timedelta(wrapper(range(5)), unit=unit)
+        tm.assert_index_equal(result, expected)
+        result = TimedeltaIndex(wrapper(range(5)), unit=unit)
+        tm.assert_index_equal(result, expected)
+
+        str_repr = [f"{x}{unit}" for x in np.arange(5)]
+        result = to_timedelta(wrapper(str_repr))
+        tm.assert_index_equal(result, expected)
+        result = to_timedelta(wrapper(str_repr))
+        tm.assert_index_equal(result, expected)
+
+        # scalar
+        expected = Timedelta(np.timedelta64(2, np_unit).astype("timedelta64[ns]"))
+        result = to_timedelta(2, unit=unit)
+        assert result == expected
+        result = Timedelta(2, unit=unit)
+        assert result == expected
+
+        result = to_timedelta(f"2{unit}")
+        assert result == expected
+        result = Timedelta(f"2{unit}")
+        assert result == expected
+
+    @pytest.mark.parametrize("unit", ["Y", "y", "M"])
+    def test_unit_m_y_raises(self, unit):
+        msg = "Units 'M', 'Y', and 'y' are no longer supported"
+        with pytest.raises(ValueError, match=msg):
+            Timedelta(10, unit)
+
+        with pytest.raises(ValueError, match=msg):
+            to_timedelta(10, unit)
+
+        with pytest.raises(ValueError, match=msg):
+            to_timedelta([1, 2], unit)
+
+    def test_numeric_conversions(self):
+        assert Timedelta(0) == np.timedelta64(0, "ns")
+        assert Timedelta(10) == np.timedelta64(10, "ns")
+        assert Timedelta(10, unit="ns") == np.timedelta64(10, "ns")
+
+        assert Timedelta(10, unit="us") == np.timedelta64(10, "us")
+        assert Timedelta(10, unit="ms") == np.timedelta64(10, "ms")
+        assert Timedelta(10, unit="s") == np.timedelta64(10, "s")
+        assert Timedelta(10, unit="d") == np.timedelta64(10, "D")
+
+    def test_timedelta_conversions(self):
+        assert Timedelta(timedelta(seconds=1)) == np.timedelta64(1, "s").astype(
+            "m8[ns]"
+        )
+        assert Timedelta(timedelta(microseconds=1)) == np.timedelta64(1, "us").astype(
+            "m8[ns]"
+        )
+        assert Timedelta(timedelta(days=1)) == np.timedelta64(1, "D").astype("m8[ns]")
+
+    def test_to_numpy_alias(self):
+        # GH 24653: alias .to_numpy() for scalars
+        td = Timedelta("10m7s")
+        assert td.to_timedelta64() == td.to_numpy()
+
+        # GH#44460
+        msg = "dtype and copy arguments are ignored"
+        with pytest.raises(ValueError, match=msg):
+            td.to_numpy("m8[s]")
+        with pytest.raises(ValueError, match=msg):
+            td.to_numpy(copy=True)
+
+    @pytest.mark.parametrize(
+        "freq,s1,s2",
+        [
+            # This first case has s1, s2 being the same as t1,t2 below
+            (
+                "N",
+                Timedelta("1 days 02:34:56.789123456"),
+                Timedelta("-1 days 02:34:56.789123456"),
+            ),
+            (
+                "U",
+                Timedelta("1 days 02:34:56.789123000"),
+                Timedelta("-1 days 02:34:56.789123000"),
+            ),
+            (
+                "L",
+                Timedelta("1 days 02:34:56.789000000"),
+                Timedelta("-1 days 02:34:56.789000000"),
+            ),
+            ("S", Timedelta("1 days 02:34:57"), Timedelta("-1 days 02:34:57")),
+            ("2S", Timedelta("1 days 02:34:56"), Timedelta("-1 days 02:34:56")),
+            ("5S", Timedelta("1 days 02:34:55"), Timedelta("-1 days 02:34:55")),
+            ("T", Timedelta("1 days 02:35:00"), Timedelta("-1 days 02:35:00")),
+            ("12T", Timedelta("1 days 02:36:00"), Timedelta("-1 days 02:36:00")),
+            ("H", Timedelta("1 days 03:00:00"), Timedelta("-1 days 03:00:00")),
+            ("d", Timedelta("1 days"), Timedelta("-1 days")),
+        ],
+    )
+    def test_round(self, freq, s1, s2):
+        t1 = Timedelta("1 days 02:34:56.789123456")
+        t2 = Timedelta("-1 days 02:34:56.789123456")
+
+        r1 = t1.round(freq)
+        assert r1 == s1
+        r2 = t2.round(freq)
+        assert r2 == s2
+
+    def test_round_invalid(self):
+        t1 = Timedelta("1 days 02:34:56.789123456")
+
+        for freq, msg in [
+            ("Y", "<YearEnd: month=12> is a non-fixed frequency"),
+            ("M", "<MonthEnd> is a non-fixed frequency"),
+            ("foobar", "Invalid frequency: foobar"),
+        ]:
+            with pytest.raises(ValueError, match=msg):
+                t1.round(freq)
+
+    def test_round_implementation_bounds(self):
+        # See also: analogous test for Timestamp
+        # GH#38964
+        result = Timedelta.min.ceil("s")
+        expected = Timedelta.min + Timedelta(seconds=1) - Timedelta(145224193)
+        assert result == expected
+
+        result = Timedelta.max.floor("s")
+        expected = Timedelta.max - Timedelta(854775807)
+        assert result == expected
+
+        with pytest.raises(OverflowError, match="value too large"):
+            Timedelta.min.floor("s")
+
+        # the second message here shows up in windows builds
+        msg = "|".join(
+            ["Python int too large to convert to C long", "int too big to convert"]
+        )
+        with pytest.raises(OverflowError, match=msg):
+            Timedelta.max.ceil("s")
+
+    @pytest.mark.xfail(reason="Failing on builds", strict=False)
+    @given(val=st.integers(min_value=iNaT + 1, max_value=lib.i8max))
+    @pytest.mark.parametrize(
+        "method", [Timedelta.round, Timedelta.floor, Timedelta.ceil]
+    )
+    def test_round_sanity(self, val, method):
+        val = np.int64(val)
+        td = Timedelta(val)
+
+        assert method(td, "ns") == td
+
+        res = method(td, "us")
+        nanos = 1000
+        assert np.abs((res - td).value) < nanos
+        assert res.value % nanos == 0
+
+        res = method(td, "ms")
+        nanos = 1_000_000
+        assert np.abs((res - td).value) < nanos
+        assert res.value % nanos == 0
+
+        res = method(td, "s")
+        nanos = 1_000_000_000
+        assert np.abs((res - td).value) < nanos
+        assert res.value % nanos == 0
+
+        res = method(td, "min")
+        nanos = 60 * 1_000_000_000
+        assert np.abs((res - td).value) < nanos
+        assert res.value % nanos == 0
+
+        res = method(td, "h")
+        nanos = 60 * 60 * 1_000_000_000
+        assert np.abs((res - td).value) < nanos
+        assert res.value % nanos == 0
+
+        res = method(td, "D")
+        nanos = 24 * 60 * 60 * 1_000_000_000
+        assert np.abs((res - td).value) < nanos
+        assert res.value % nanos == 0
+
+    @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s"])
+    def test_round_non_nano(self, unit):
+        td = Timedelta("1 days 02:34:57").as_unit(unit)
+
+        res = td.round("min")
+        assert res == Timedelta("1 days 02:35:00")
+        assert res._creso == td._creso
+
+        res = td.floor("min")
+        assert res == Timedelta("1 days 02:34:00")
+        assert res._creso == td._creso
+
+        res = td.ceil("min")
+        assert res == Timedelta("1 days 02:35:00")
+        assert res._creso == td._creso
+
+    def test_identity(self):
+        td = Timedelta(10, unit="d")
+        assert isinstance(td, Timedelta)
+        assert isinstance(td, timedelta)
+
+    def test_short_format_converters(self):
+        def conv(v):
+            return v.astype("m8[ns]")
+
+        assert Timedelta("10") == np.timedelta64(10, "ns")
+        assert Timedelta("10ns") == np.timedelta64(10, "ns")
+        assert Timedelta("100") == np.timedelta64(100, "ns")
+        assert Timedelta("100ns") == np.timedelta64(100, "ns")
+
+        assert Timedelta("1000") == np.timedelta64(1000, "ns")
+        assert Timedelta("1000ns") == np.timedelta64(1000, "ns")
+        assert Timedelta("1000NS") == np.timedelta64(1000, "ns")
+
+        assert Timedelta("10us") == np.timedelta64(10000, "ns")
+        assert Timedelta("100us") == np.timedelta64(100000, "ns")
+        assert Timedelta("1000us") == np.timedelta64(1000000, "ns")
+        assert Timedelta("1000Us") == np.timedelta64(1000000, "ns")
+        assert Timedelta("1000uS") == np.timedelta64(1000000, "ns")
+
+        assert Timedelta("1ms") == np.timedelta64(1000000, "ns")
+        assert Timedelta("10ms") == np.timedelta64(10000000, "ns")
+        assert Timedelta("100ms") == np.timedelta64(100000000, "ns")
+        assert Timedelta("1000ms") == np.timedelta64(1000000000, "ns")
+
+        assert Timedelta("-1s") == -np.timedelta64(1000000000, "ns")
+        assert Timedelta("1s") == np.timedelta64(1000000000, "ns")
+        assert Timedelta("10s") == np.timedelta64(10000000000, "ns")
+        assert Timedelta("100s") == np.timedelta64(100000000000, "ns")
+        assert Timedelta("1000s") == np.timedelta64(1000000000000, "ns")
+
+        assert Timedelta("1d") == conv(np.timedelta64(1, "D"))
+        assert Timedelta("-1d") == -conv(np.timedelta64(1, "D"))
+        assert Timedelta("1D") == conv(np.timedelta64(1, "D"))
+        assert Timedelta("10D") == conv(np.timedelta64(10, "D"))
+        assert Timedelta("100D") == conv(np.timedelta64(100, "D"))
+        assert Timedelta("1000D") == conv(np.timedelta64(1000, "D"))
+        assert Timedelta("10000D") == conv(np.timedelta64(10000, "D"))
+
+        # space
+        assert Timedelta(" 10000D ") == conv(np.timedelta64(10000, "D"))
+        assert Timedelta(" - 10000D ") == -conv(np.timedelta64(10000, "D"))
+
+        # invalid
+        msg = "invalid unit abbreviation"
+        with pytest.raises(ValueError, match=msg):
+            Timedelta("1foo")
+        msg = "unit abbreviation w/o a number"
+        with pytest.raises(ValueError, match=msg):
+            Timedelta("foo")
+
+    def test_full_format_converters(self):
+        def conv(v):
+            return v.astype("m8[ns]")
+
+        d1 = np.timedelta64(1, "D")
+
+        assert Timedelta("1days") == conv(d1)
+        assert Timedelta("1days,") == conv(d1)
+        assert Timedelta("- 1days,") == -conv(d1)
+
+        assert Timedelta("00:00:01") == conv(np.timedelta64(1, "s"))
+        assert Timedelta("06:00:01") == conv(np.timedelta64(6 * 3600 + 1, "s"))
+        assert Timedelta("06:00:01.0") == conv(np.timedelta64(6 * 3600 + 1, "s"))
+        assert Timedelta("06:00:01.01") == conv(
+            np.timedelta64(1000 * (6 * 3600 + 1) + 10, "ms")
+        )
+
+        assert Timedelta("- 1days, 00:00:01") == conv(-d1 + np.timedelta64(1, "s"))
+        assert Timedelta("1days, 06:00:01") == conv(
+            d1 + np.timedelta64(6 * 3600 + 1, "s")
+        )
+        assert Timedelta("1days, 06:00:01.01") == conv(
+            d1 + np.timedelta64(1000 * (6 * 3600 + 1) + 10, "ms")
+        )
+
+        # invalid
+        msg = "have leftover units"
+        with pytest.raises(ValueError, match=msg):
+            Timedelta("- 1days, 00")
+
+    def test_pickle(self):
+        v = Timedelta("1 days 10:11:12.0123456")
+        v_p = tm.round_trip_pickle(v)
+        assert v == v_p
+
+    def test_timedelta_hash_equality(self):
+        # GH 11129
+        v = Timedelta(1, "D")
+        td = timedelta(days=1)
+        assert hash(v) == hash(td)
+
+        d = {td: 2}
+        assert d[v] == 2
+
+        tds = [Timedelta(seconds=1) + Timedelta(days=n) for n in range(20)]
+        assert all(hash(td) == hash(td.to_pytimedelta()) for td in tds)
+
+        # python timedeltas drop ns resolution
+        ns_td = Timedelta(1, "ns")
+        assert hash(ns_td) != hash(ns_td.to_pytimedelta())
+
+    def test_implementation_limits(self):
+        min_td = Timedelta(Timedelta.min)
+        max_td = Timedelta(Timedelta.max)
+
+        # GH 12727
+        # timedelta limits correspond to int64 boundaries
+        assert min_td._value == iNaT + 1
+        assert max_td._value == lib.i8max
+
+        # Beyond lower limit, a NAT before the Overflow
+        assert (min_td - Timedelta(1, "ns")) is NaT
+
+        msg = "int too (large|big) to convert"
+        with pytest.raises(OverflowError, match=msg):
+            min_td - Timedelta(2, "ns")
+
+        with pytest.raises(OverflowError, match=msg):
+            max_td + Timedelta(1, "ns")
+
+        # Same tests using the internal nanosecond values
+        td = Timedelta(min_td._value - 1, "ns")
+        assert td is NaT
+
+        msg = "Cannot cast -9223372036854775809 from ns to 'ns' without overflow"
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
+            Timedelta(min_td._value - 2, "ns")
+
+        msg = "Cannot cast 9223372036854775808 from ns to 'ns' without overflow"
+        with pytest.raises(OutOfBoundsTimedelta, match=msg):
+            Timedelta(max_td._value + 1, "ns")
+
+    def test_total_seconds_precision(self):
+        # GH 19458
+        assert Timedelta("30S").total_seconds() == 30.0
+        assert Timedelta("0").total_seconds() == 0.0
+        assert Timedelta("-2S").total_seconds() == -2.0
+        assert Timedelta("5.324S").total_seconds() == 5.324
+        assert (Timedelta("30S").total_seconds() - 30.0) < 1e-20
+        assert (30.0 - Timedelta("30S").total_seconds()) < 1e-20
+
+    def test_resolution_string(self):
+        assert Timedelta(days=1).resolution_string == "D"
+        assert Timedelta(days=1, hours=6).resolution_string == "H"
+        assert Timedelta(days=1, minutes=6).resolution_string == "T"
+        assert Timedelta(days=1, seconds=6).resolution_string == "S"
+        assert Timedelta(days=1, milliseconds=6).resolution_string == "L"
+        assert Timedelta(days=1, microseconds=6).resolution_string == "U"
+        assert Timedelta(days=1, nanoseconds=6).resolution_string == "N"
+
+    def test_resolution_deprecated(self):
+        # GH#21344
+        td = Timedelta(days=4, hours=3)
+        result = td.resolution
+        assert result == Timedelta(nanoseconds=1)
+
+        # Check that the attribute is available on the class, mirroring
+        #  the stdlib timedelta behavior
+        result = Timedelta.resolution
+        assert result == Timedelta(nanoseconds=1)
+
+
+@pytest.mark.parametrize(
+    "value, expected",
+    [
+        (Timedelta("10S"), True),
+        (Timedelta("-10S"), True),
+        (Timedelta(10, unit="ns"), True),
+        (Timedelta(0, unit="ns"), False),
+        (Timedelta(-10, unit="ns"), True),
+        (Timedelta(None), True),
+        (NaT, True),
+    ],
+)
+def test_truthiness(value, expected):
+    # https://github.com/pandas-dev/pandas/issues/21484
+    assert bool(value) is expected
+
+
+def test_timedelta_attribute_precision():
+    # GH 31354
+    td = Timedelta(1552211999999999872, unit="ns")
+    result = td.days * 86400
+    result += td.seconds
+    result *= 1000000
+    result += td.microseconds
+    result *= 1000
+    result += td.nanoseconds
+    expected = td._value
+    assert result == expected

videochat2/lib/python3.10/site-packages/pandas/tests/scalar/timestamp/test_arithmetic.py

@@ -0,0 +1,295 @@
+from datetime import (
+    datetime,
+    timedelta,
+    timezone,
+)
+
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs import (
+    OutOfBoundsDatetime,
+    OutOfBoundsTimedelta,
+    Timedelta,
+    Timestamp,
+    offsets,
+    to_offset,
+)
+
+import pandas._testing as tm
+
+
+class TestTimestampArithmetic:
+    def test_overflow_offset(self):
+        # no overflow expected
+
+        stamp = Timestamp("2000/1/1")
+        offset_no_overflow = to_offset("D") * 100
+
+        expected = Timestamp("2000/04/10")
+        assert stamp + offset_no_overflow == expected
+
+        assert offset_no_overflow + stamp == expected
+
+        expected = Timestamp("1999/09/23")
+        assert stamp - offset_no_overflow == expected
+
+    def test_overflow_offset_raises(self):
+        # xref https://github.com/statsmodels/statsmodels/issues/3374
+        # ends up multiplying really large numbers which overflow
+
+        stamp = Timestamp("2017-01-13 00:00:00").as_unit("ns")
+        offset_overflow = 20169940 * offsets.Day(1)
+        msg = (
+            "the add operation between "
+            r"\<-?\d+ \* Days\> and \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} "
+            "will overflow"
+        )
+        lmsg2 = r"Cannot cast -?20169940 days \+?00:00:00 to unit='ns' without overflow"
+
+        with pytest.raises(OutOfBoundsTimedelta, match=lmsg2):
+            stamp + offset_overflow
+
+        with pytest.raises(OverflowError, match=msg):
+            offset_overflow + stamp
+
+        with pytest.raises(OutOfBoundsTimedelta, match=lmsg2):
+            stamp - offset_overflow
+
+        # xref https://github.com/pandas-dev/pandas/issues/14080
+        # used to crash, so check for proper overflow exception
+
+        stamp = Timestamp("2000/1/1").as_unit("ns")
+        offset_overflow = to_offset("D") * 100**5
+
+        lmsg3 = (
+            r"Cannot cast -?10000000000 days \+?00:00:00 to unit='ns' without overflow"
+        )
+        with pytest.raises(OutOfBoundsTimedelta, match=lmsg3):
+            stamp + offset_overflow
+
+        with pytest.raises(OverflowError, match=msg):
+            offset_overflow + stamp
+
+        with pytest.raises(OutOfBoundsTimedelta, match=lmsg3):
+            stamp - offset_overflow
+
+    def test_overflow_timestamp_raises(self):
+        # https://github.com/pandas-dev/pandas/issues/31774
+        msg = "Result is too large"
+        a = Timestamp("2101-01-01 00:00:00").as_unit("ns")
+        b = Timestamp("1688-01-01 00:00:00").as_unit("ns")
+
+        with pytest.raises(OutOfBoundsDatetime, match=msg):
+            a - b
+
+        # but we're OK for timestamp and datetime.datetime
+        assert (a - b.to_pydatetime()) == (a.to_pydatetime() - b)
+
+    def test_delta_preserve_nanos(self):
+        val = Timestamp(1337299200000000123)
+        result = val + timedelta(1)
+        assert result.nanosecond == val.nanosecond
+
+    def test_rsub_dtscalars(self, tz_naive_fixture):
+        # In particular, check that datetime64 - Timestamp works GH#28286
+        td = Timedelta(1235345642000)
+        ts = Timestamp("2021-01-01", tz=tz_naive_fixture)
+        other = ts + td
+
+        assert other - ts == td
+        assert other.to_pydatetime() - ts == td
+        if tz_naive_fixture is None:
+            assert other.to_datetime64() - ts == td
+        else:
+            msg = "Cannot subtract tz-naive and tz-aware datetime-like objects"
+            with pytest.raises(TypeError, match=msg):
+                other.to_datetime64() - ts
+
+    def test_timestamp_sub_datetime(self):
+        dt = datetime(2013, 10, 12)
+        ts = Timestamp(datetime(2013, 10, 13))
+        assert (ts - dt).days == 1
+        assert (dt - ts).days == -1
+
+    def test_subtract_tzaware_datetime(self):
+        t1 = Timestamp("2020-10-22T22:00:00+00:00")
+        t2 = datetime(2020, 10, 22, 22, tzinfo=timezone.utc)
+
+        result = t1 - t2
+
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta("0 days")
+
+    def test_subtract_timestamp_from_different_timezone(self):
+        t1 = Timestamp("20130101").tz_localize("US/Eastern")
+        t2 = Timestamp("20130101").tz_localize("CET")
+
+        result = t1 - t2
+
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta("0 days 06:00:00")
+
+    def test_subtracting_involving_datetime_with_different_tz(self):
+        t1 = datetime(2013, 1, 1, tzinfo=timezone(timedelta(hours=-5)))
+        t2 = Timestamp("20130101").tz_localize("CET")
+
+        result = t1 - t2
+
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta("0 days 06:00:00")
+
+        result = t2 - t1
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta("-1 days +18:00:00")
+
+    def test_subtracting_different_timezones(self, tz_aware_fixture):
+        t_raw = Timestamp("20130101")
+        t_UTC = t_raw.tz_localize("UTC")
+        t_diff = t_UTC.tz_convert(tz_aware_fixture) + Timedelta("0 days 05:00:00")
+
+        result = t_diff - t_UTC
+
+        assert isinstance(result, Timedelta)
+        assert result == Timedelta("0 days 05:00:00")
+
+    def test_addition_subtraction_types(self):
+        # Assert on the types resulting from Timestamp +/- various date/time
+        # objects
+        dt = datetime(2014, 3, 4)
+        td = timedelta(seconds=1)
+        ts = Timestamp(dt)
+
+        msg = "Addition/subtraction of integers"
+        with pytest.raises(TypeError, match=msg):
+            # GH#22535 add/sub with integers is deprecated
+            ts + 1
+        with pytest.raises(TypeError, match=msg):
+            ts - 1
+
+        # Timestamp + datetime not supported, though subtraction is supported
+        # and yields timedelta more tests in tseries/base/tests/test_base.py
+        assert type(ts - dt) == Timedelta
+        assert type(ts + td) == Timestamp
+        assert type(ts - td) == Timestamp
+
+        # Timestamp +/- datetime64 not supported, so not tested (could possibly
+        # assert error raised?)
+        td64 = np.timedelta64(1, "D")
+        assert type(ts + td64) == Timestamp
+        assert type(ts - td64) == Timestamp
+
+    @pytest.mark.parametrize(
+        "td", [Timedelta(hours=3), np.timedelta64(3, "h"), timedelta(hours=3)]
+    )
+    def test_radd_tdscalar(self, td, fixed_now_ts):
+        # GH#24775 timedelta64+Timestamp should not raise
+        ts = fixed_now_ts
+        assert td + ts == ts + td
+
+    @pytest.mark.parametrize(
+        "other,expected_difference",
+        [
+            (np.timedelta64(-123, "ns"), -123),
+            (np.timedelta64(1234567898, "ns"), 1234567898),
+            (np.timedelta64(-123, "us"), -123000),
+            (np.timedelta64(-123, "ms"), -123000000),
+        ],
+    )
+    def test_timestamp_add_timedelta64_unit(self, other, expected_difference):
+        now = datetime.utcnow()
+        ts = Timestamp(now).as_unit("ns")
+        result = ts + other
+        valdiff = result._value - ts._value
+        assert valdiff == expected_difference
+
+        ts2 = Timestamp(now)
+        assert ts2 + other == result
+
+    @pytest.mark.parametrize(
+        "ts",
+        [
+            Timestamp("1776-07-04"),
+            Timestamp("1776-07-04", tz="UTC"),
+        ],
+    )
+    @pytest.mark.parametrize(
+        "other",
+        [
+            1,
+            np.int64(1),
+            np.array([1, 2], dtype=np.int32),
+            np.array([3, 4], dtype=np.uint64),
+        ],
+    )
+    def test_add_int_with_freq(self, ts, other):
+        msg = "Addition/subtraction of integers and integer-arrays"
+        with pytest.raises(TypeError, match=msg):
+            ts + other
+        with pytest.raises(TypeError, match=msg):
+            other + ts
+
+        with pytest.raises(TypeError, match=msg):
+            ts - other
+
+        msg = "unsupported operand type"
+        with pytest.raises(TypeError, match=msg):
+            other - ts
+
+    @pytest.mark.parametrize("shape", [(6,), (2, 3)])
+    def test_addsub_m8ndarray(self, shape):
+        # GH#33296
+        ts = Timestamp("2020-04-04 15:45").as_unit("ns")
+        other = np.arange(6).astype("m8[h]").reshape(shape)
+
+        result = ts + other
+
+        ex_stamps = [ts + Timedelta(hours=n) for n in range(6)]
+        expected = np.array([x.asm8 for x in ex_stamps], dtype="M8[ns]").reshape(shape)
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = other + ts
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = ts - other
+        ex_stamps = [ts - Timedelta(hours=n) for n in range(6)]
+        expected = np.array([x.asm8 for x in ex_stamps], dtype="M8[ns]").reshape(shape)
+        tm.assert_numpy_array_equal(result, expected)
+
+        msg = r"unsupported operand type\(s\) for -: 'numpy.ndarray' and 'Timestamp'"
+        with pytest.raises(TypeError, match=msg):
+            other - ts
+
+    @pytest.mark.parametrize("shape", [(6,), (2, 3)])
+    def test_addsub_m8ndarray_tzaware(self, shape):
+        # GH#33296
+        ts = Timestamp("2020-04-04 15:45", tz="US/Pacific")
+
+        other = np.arange(6).astype("m8[h]").reshape(shape)
+
+        result = ts + other
+
+        ex_stamps = [ts + Timedelta(hours=n) for n in range(6)]
+        expected = np.array(ex_stamps).reshape(shape)
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = other + ts
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = ts - other
+        ex_stamps = [ts - Timedelta(hours=n) for n in range(6)]
+        expected = np.array(ex_stamps).reshape(shape)
+        tm.assert_numpy_array_equal(result, expected)
+
+        msg = r"unsupported operand type\(s\) for -: 'numpy.ndarray' and 'Timestamp'"
+        with pytest.raises(TypeError, match=msg):
+            other - ts
+
+    def test_subtract_different_utc_objects(self, utc_fixture, utc_fixture2):
+        # GH 32619
+        dt = datetime(2021, 1, 1)
+        ts1 = Timestamp(dt, tz=utc_fixture)
+        ts2 = Timestamp(dt, tz=utc_fixture2)
+        result = ts1 - ts2
+        expected = Timedelta(0)
+        assert result == expected

videochat2/lib/python3.10/site-packages/pandas/tests/scalar/timestamp/test_comparisons.py

@@ -0,0 +1,313 @@
+from datetime import (
+    datetime,
+    timedelta,
+)
+import operator
+
+import numpy as np
+import pytest
+
+from pandas import Timestamp
+import pandas._testing as tm
+
+
+class TestTimestampComparison:
+    def test_compare_non_nano_dt64(self):
+        # don't raise when converting dt64 to Timestamp in __richcmp__
+        dt = np.datetime64("1066-10-14")
+        ts = Timestamp(dt)
+
+        assert dt == ts
+
+    def test_comparison_dt64_ndarray(self):
+        ts = Timestamp("2021-01-01")
+        ts2 = Timestamp("2019-04-05")
+        arr = np.array([[ts.asm8, ts2.asm8]], dtype="M8[ns]")
+
+        result = ts == arr
+        expected = np.array([[True, False]], dtype=bool)
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = arr == ts
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = ts != arr
+        tm.assert_numpy_array_equal(result, ~expected)
+
+        result = arr != ts
+        tm.assert_numpy_array_equal(result, ~expected)
+
+        result = ts2 < arr
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = arr < ts2
+        tm.assert_numpy_array_equal(result, np.array([[False, False]], dtype=bool))
+
+        result = ts2 <= arr
+        tm.assert_numpy_array_equal(result, np.array([[True, True]], dtype=bool))
+
+        result = arr <= ts2
+        tm.assert_numpy_array_equal(result, ~expected)
+
+        result = ts >= arr
+        tm.assert_numpy_array_equal(result, np.array([[True, True]], dtype=bool))
+
+        result = arr >= ts
+        tm.assert_numpy_array_equal(result, np.array([[True, False]], dtype=bool))
+
+    @pytest.mark.parametrize("reverse", [True, False])
+    def test_comparison_dt64_ndarray_tzaware(self, reverse, comparison_op):
+        ts = Timestamp("2021-01-01 00:00:00.00000", tz="UTC")
+        arr = np.array([ts.asm8, ts.asm8], dtype="M8[ns]")
+
+        left, right = ts, arr
+        if reverse:
+            left, right = arr, ts
+
+        if comparison_op is operator.eq:
+            expected = np.array([False, False], dtype=bool)
+            result = comparison_op(left, right)
+            tm.assert_numpy_array_equal(result, expected)
+        elif comparison_op is operator.ne:
+            expected = np.array([True, True], dtype=bool)
+            result = comparison_op(left, right)
+            tm.assert_numpy_array_equal(result, expected)
+        else:
+            msg = "Cannot compare tz-naive and tz-aware timestamps"
+            with pytest.raises(TypeError, match=msg):
+                comparison_op(left, right)
+
+    def test_comparison_object_array(self):
+        # GH#15183
+        ts = Timestamp("2011-01-03 00:00:00-0500", tz="US/Eastern")
+        other = Timestamp("2011-01-01 00:00:00-0500", tz="US/Eastern")
+        naive = Timestamp("2011-01-01 00:00:00")
+
+        arr = np.array([other, ts], dtype=object)
+        res = arr == ts
+        expected = np.array([False, True], dtype=bool)
+        assert (res == expected).all()
+
+        # 2D case
+        arr = np.array([[other, ts], [ts, other]], dtype=object)
+        res = arr != ts
+        expected = np.array([[True, False], [False, True]], dtype=bool)
+        assert res.shape == expected.shape
+        assert (res == expected).all()
+
+        # tzaware mismatch
+        arr = np.array([naive], dtype=object)
+        msg = "Cannot compare tz-naive and tz-aware timestamps"
+        with pytest.raises(TypeError, match=msg):
+            arr < ts
+
+    def test_comparison(self):
+        # 5-18-2012 00:00:00.000
+        stamp = 1337299200000000000
+
+        val = Timestamp(stamp)
+
+        assert val == val
+        assert not val != val
+        assert not val < val
+        assert val <= val
+        assert not val > val
+        assert val >= val
+
+        other = datetime(2012, 5, 18)
+        assert val == other
+        assert not val != other
+        assert not val < other
+        assert val <= other
+        assert not val > other
+        assert val >= other
+
+        other = Timestamp(stamp + 100)
+
+        assert val != other
+        assert val != other
+        assert val < other
+        assert val <= other
+        assert other > val
+        assert other >= val
+
+    def test_compare_invalid(self):
+        # GH#8058
+        val = Timestamp("20130101 12:01:02")
+        assert not val == "foo"
+        assert not val == 10.0
+        assert not val == 1
+        assert not val == []
+        assert not val == {"foo": 1}
+        assert not val == np.float64(1)
+        assert not val == np.int64(1)
+
+        assert val != "foo"
+        assert val != 10.0
+        assert val != 1
+        assert val != []
+        assert val != {"foo": 1}
+        assert val != np.float64(1)
+        assert val != np.int64(1)
+
+    @pytest.mark.parametrize("tz", [None, "US/Pacific"])
+    def test_compare_date(self, tz):
+        # GH#36131 comparing Timestamp with date object is deprecated
+        ts = Timestamp("2021-01-01 00:00:00.00000", tz=tz)
+        dt = ts.to_pydatetime().date()
+        # in 2.0 we disallow comparing pydate objects with Timestamps,
+        #  following the stdlib datetime behavior.
+
+        msg = "Cannot compare Timestamp with datetime.date"
+        for left, right in [(ts, dt), (dt, ts)]:
+            assert not left == right
+            assert left != right
+
+            with pytest.raises(TypeError, match=msg):
+                left < right
+            with pytest.raises(TypeError, match=msg):
+                left <= right
+            with pytest.raises(TypeError, match=msg):
+                left > right
+            with pytest.raises(TypeError, match=msg):
+                left >= right
+
+    def test_cant_compare_tz_naive_w_aware(self, utc_fixture):
+        # see GH#1404
+        a = Timestamp("3/12/2012")
+        b = Timestamp("3/12/2012", tz=utc_fixture)
+
+        msg = "Cannot compare tz-naive and tz-aware timestamps"
+        assert not a == b
+        assert a != b
+        with pytest.raises(TypeError, match=msg):
+            a < b
+        with pytest.raises(TypeError, match=msg):
+            a <= b
+        with pytest.raises(TypeError, match=msg):
+            a > b
+        with pytest.raises(TypeError, match=msg):
+            a >= b
+
+        assert not b == a
+        assert b != a
+        with pytest.raises(TypeError, match=msg):
+            b < a
+        with pytest.raises(TypeError, match=msg):
+            b <= a
+        with pytest.raises(TypeError, match=msg):
+            b > a
+        with pytest.raises(TypeError, match=msg):
+            b >= a
+
+        assert not a == b.to_pydatetime()
+        assert not a.to_pydatetime() == b
+
+    def test_timestamp_compare_scalars(self):
+        # case where ndim == 0
+        lhs = np.datetime64(datetime(2013, 12, 6))
+        rhs = Timestamp("now")
+        nat = Timestamp("nat")
+
+        ops = {"gt": "lt", "lt": "gt", "ge": "le", "le": "ge", "eq": "eq", "ne": "ne"}
+
+        for left, right in ops.items():
+            left_f = getattr(operator, left)
+            right_f = getattr(operator, right)
+            expected = left_f(lhs, rhs)
+
+            result = right_f(rhs, lhs)
+            assert result == expected
+
+            expected = left_f(rhs, nat)
+            result = right_f(nat, rhs)
+            assert result == expected
+
+    def test_timestamp_compare_with_early_datetime(self):
+        # e.g. datetime.min
+        stamp = Timestamp("2012-01-01")
+
+        assert not stamp == datetime.min
+        assert not stamp == datetime(1600, 1, 1)
+        assert not stamp == datetime(2700, 1, 1)
+        assert stamp != datetime.min
+        assert stamp != datetime(1600, 1, 1)
+        assert stamp != datetime(2700, 1, 1)
+        assert stamp > datetime(1600, 1, 1)
+        assert stamp >= datetime(1600, 1, 1)
+        assert stamp < datetime(2700, 1, 1)
+        assert stamp <= datetime(2700, 1, 1)
+
+        other = Timestamp.min.to_pydatetime(warn=False)
+        assert other - timedelta(microseconds=1) < Timestamp.min
+
+    def test_timestamp_compare_oob_dt64(self):
+        us = np.timedelta64(1, "us")
+        other = np.datetime64(Timestamp.min).astype("M8[us]")
+
+        # This may change if the implementation bound is dropped to match
+        #  DatetimeArray/DatetimeIndex GH#24124
+        assert Timestamp.min > other
+        # Note: numpy gets the reversed comparison wrong
+
+        other = np.datetime64(Timestamp.max).astype("M8[us]")
+        assert Timestamp.max > other  # not actually OOB
+        assert other < Timestamp.max
+
+        assert Timestamp.max < other + us
+        # Note: numpy gets the reversed comparison wrong
+
+        # GH-42794
+        other = datetime(9999, 9, 9)
+        assert Timestamp.min < other
+        assert other > Timestamp.min
+        assert Timestamp.max < other
+        assert other > Timestamp.max
+
+        other = datetime(1, 1, 1)
+        assert Timestamp.max > other
+        assert other < Timestamp.max
+        assert Timestamp.min > other
+        assert other < Timestamp.min
+
+    def test_compare_zerodim_array(self, fixed_now_ts):
+        # GH#26916
+        ts = fixed_now_ts
+        dt64 = np.datetime64("2016-01-01", "ns")
+        arr = np.array(dt64)
+        assert arr.ndim == 0
+
+        result = arr < ts
+        assert result is np.bool_(True)
+        result = arr > ts
+        assert result is np.bool_(False)
+
+
+def test_rich_comparison_with_unsupported_type():
+    # Comparisons with unsupported objects should return NotImplemented
+    # (it previously raised TypeError, see #24011)
+
+    class Inf:
+        def __lt__(self, o):
+            return False
+
+        def __le__(self, o):
+            return isinstance(o, Inf)
+
+        def __gt__(self, o):
+            return not isinstance(o, Inf)
+
+        def __ge__(self, o):
+            return True
+
+        def __eq__(self, other) -> bool:
+            return isinstance(other, Inf)
+
+    inf = Inf()
+    timestamp = Timestamp("2018-11-30")
+
+    for left, right in [(inf, timestamp), (timestamp, inf)]:
+        assert left > right or left < right
+        assert left >= right or left <= right
+        assert not left == right  # pylint: disable=unneeded-not
+        assert left != right