Updated script that can be controled by Nodejs web app

lib/python3.13/site-packages/pandas/tests/indexes/datetimes/test_scalar_compat.py

@@ -0,0 +1,329 @@
+"""
+Tests for DatetimeIndex methods behaving like their Timestamp counterparts
+"""
+
+import calendar
+from datetime import (
+    date,
+    datetime,
+    time,
+)
+import locale
+import unicodedata
+
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs import timezones
+
+from pandas import (
+    DatetimeIndex,
+    Index,
+    NaT,
+    Timestamp,
+    date_range,
+    offsets,
+)
+import pandas._testing as tm
+from pandas.core.arrays import DatetimeArray
+
+
+class TestDatetimeIndexOps:
+    def test_dti_no_millisecond_field(self):
+        msg = "type object 'DatetimeIndex' has no attribute 'millisecond'"
+        with pytest.raises(AttributeError, match=msg):
+            DatetimeIndex.millisecond
+
+        msg = "'DatetimeIndex' object has no attribute 'millisecond'"
+        with pytest.raises(AttributeError, match=msg):
+            DatetimeIndex([]).millisecond
+
+    def test_dti_time(self):
+        rng = date_range("1/1/2000", freq="12min", periods=10)
+        result = Index(rng).time
+        expected = [t.time() for t in rng]
+        assert (result == expected).all()
+
+    def test_dti_date(self):
+        rng = date_range("1/1/2000", freq="12h", periods=10)
+        result = Index(rng).date
+        expected = [t.date() for t in rng]
+        assert (result == expected).all()
+
+    @pytest.mark.parametrize(
+        "dtype",
+        [None, "datetime64[ns, CET]", "datetime64[ns, EST]", "datetime64[ns, UTC]"],
+    )
+    def test_dti_date2(self, dtype):
+        # Regression test for GH#21230
+        expected = np.array([date(2018, 6, 4), NaT])
+
+        index = DatetimeIndex(["2018-06-04 10:00:00", NaT], dtype=dtype)
+        result = index.date
+
+        tm.assert_numpy_array_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "dtype",
+        [None, "datetime64[ns, CET]", "datetime64[ns, EST]", "datetime64[ns, UTC]"],
+    )
+    def test_dti_time2(self, dtype):
+        # Regression test for GH#21267
+        expected = np.array([time(10, 20, 30), NaT])
+
+        index = DatetimeIndex(["2018-06-04 10:20:30", NaT], dtype=dtype)
+        result = index.time
+
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_dti_timetz(self, tz_naive_fixture):
+        # GH#21358
+        tz = timezones.maybe_get_tz(tz_naive_fixture)
+
+        expected = np.array([time(10, 20, 30, tzinfo=tz), NaT])
+
+        index = DatetimeIndex(["2018-06-04 10:20:30", NaT], tz=tz)
+        result = index.timetz
+
+        tm.assert_numpy_array_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "field",
+        [
+            "dayofweek",
+            "day_of_week",
+            "dayofyear",
+            "day_of_year",
+            "quarter",
+            "days_in_month",
+            "is_month_start",
+            "is_month_end",
+            "is_quarter_start",
+            "is_quarter_end",
+            "is_year_start",
+            "is_year_end",
+        ],
+    )
+    def test_dti_timestamp_fields(self, field):
+        # extra fields from DatetimeIndex like quarter and week
+        idx = date_range("2020-01-01", periods=10)
+        expected = getattr(idx, field)[-1]
+
+        result = getattr(Timestamp(idx[-1]), field)
+        assert result == expected
+
+    def test_dti_nanosecond(self):
+        dti = DatetimeIndex(np.arange(10))
+        expected = Index(np.arange(10, dtype=np.int32))
+
+        tm.assert_index_equal(dti.nanosecond, expected)
+
+    @pytest.mark.parametrize("prefix", ["", "dateutil/"])
+    def test_dti_hour_tzaware(self, prefix):
+        strdates = ["1/1/2012", "3/1/2012", "4/1/2012"]
+        rng = DatetimeIndex(strdates, tz=prefix + "US/Eastern")
+        assert (rng.hour == 0).all()
+
+        # a more unusual time zone, GH#1946
+        dr = date_range(
+            "2011-10-02 00:00", freq="h", periods=10, tz=prefix + "America/Atikokan"
+        )
+
+        expected = Index(np.arange(10, dtype=np.int32))
+        tm.assert_index_equal(dr.hour, expected)
+
+    # GH#12806
+    # error: Unsupported operand types for + ("List[None]" and "List[str]")
+    @pytest.mark.parametrize(
+        "time_locale", [None] + tm.get_locales()  # type: ignore[operator]
+    )
+    def test_day_name_month_name(self, time_locale):
+        # Test Monday -> Sunday and January -> December, in that sequence
+        if time_locale is None:
+            # If the time_locale is None, day-name and month_name should
+            # return the english attributes
+            expected_days = [
+                "Monday",
+                "Tuesday",
+                "Wednesday",
+                "Thursday",
+                "Friday",
+                "Saturday",
+                "Sunday",
+            ]
+            expected_months = [
+                "January",
+                "February",
+                "March",
+                "April",
+                "May",
+                "June",
+                "July",
+                "August",
+                "September",
+                "October",
+                "November",
+                "December",
+            ]
+        else:
+            with tm.set_locale(time_locale, locale.LC_TIME):
+                expected_days = calendar.day_name[:]
+                expected_months = calendar.month_name[1:]
+
+        # GH#11128
+        dti = date_range(freq="D", start=datetime(1998, 1, 1), periods=365)
+        english_days = [
+            "Monday",
+            "Tuesday",
+            "Wednesday",
+            "Thursday",
+            "Friday",
+            "Saturday",
+            "Sunday",
+        ]
+        for day, name, eng_name in zip(range(4, 11), expected_days, english_days):
+            name = name.capitalize()
+            assert dti.day_name(locale=time_locale)[day] == name
+            assert dti.day_name(locale=None)[day] == eng_name
+            ts = Timestamp(datetime(2016, 4, day))
+            assert ts.day_name(locale=time_locale) == name
+        dti = dti.append(DatetimeIndex([NaT]))
+        assert np.isnan(dti.day_name(locale=time_locale)[-1])
+        ts = Timestamp(NaT)
+        assert np.isnan(ts.day_name(locale=time_locale))
+
+        # GH#12805
+        dti = date_range(freq="ME", start="2012", end="2013")
+        result = dti.month_name(locale=time_locale)
+        expected = Index([month.capitalize() for month in expected_months])
+
+        # work around different normalization schemes GH#22342
+        result = result.str.normalize("NFD")
+        expected = expected.str.normalize("NFD")
+
+        tm.assert_index_equal(result, expected)
+
+        for item, expected in zip(dti, expected_months):
+            result = item.month_name(locale=time_locale)
+            expected = expected.capitalize()
+
+            result = unicodedata.normalize("NFD", result)
+            expected = unicodedata.normalize("NFD", result)
+
+            assert result == expected
+        dti = dti.append(DatetimeIndex([NaT]))
+        assert np.isnan(dti.month_name(locale=time_locale)[-1])
+
+    def test_dti_week(self):
+        # GH#6538: Check that DatetimeIndex and its TimeStamp elements
+        # return the same weekofyear accessor close to new year w/ tz
+        dates = ["2013/12/29", "2013/12/30", "2013/12/31"]
+        dates = DatetimeIndex(dates, tz="Europe/Brussels")
+        expected = [52, 1, 1]
+        assert dates.isocalendar().week.tolist() == expected
+        assert [d.weekofyear for d in dates] == expected
+
+    @pytest.mark.parametrize("tz", [None, "US/Eastern"])
+    def test_dti_fields(self, tz):
+        # GH#13303
+        dti = date_range(freq="D", start=datetime(1998, 1, 1), periods=365, tz=tz)
+        assert dti.year[0] == 1998
+        assert dti.month[0] == 1
+        assert dti.day[0] == 1
+        assert dti.hour[0] == 0
+        assert dti.minute[0] == 0
+        assert dti.second[0] == 0
+        assert dti.microsecond[0] == 0
+        assert dti.dayofweek[0] == 3
+
+        assert dti.dayofyear[0] == 1
+        assert dti.dayofyear[120] == 121
+
+        assert dti.isocalendar().week.iloc[0] == 1
+        assert dti.isocalendar().week.iloc[120] == 18
+
+        assert dti.quarter[0] == 1
+        assert dti.quarter[120] == 2
+
+        assert dti.days_in_month[0] == 31
+        assert dti.days_in_month[90] == 30
+
+        assert dti.is_month_start[0]
+        assert not dti.is_month_start[1]
+        assert dti.is_month_start[31]
+        assert dti.is_quarter_start[0]
+        assert dti.is_quarter_start[90]
+        assert dti.is_year_start[0]
+        assert not dti.is_year_start[364]
+        assert not dti.is_month_end[0]
+        assert dti.is_month_end[30]
+        assert not dti.is_month_end[31]
+        assert dti.is_month_end[364]
+        assert not dti.is_quarter_end[0]
+        assert not dti.is_quarter_end[30]
+        assert dti.is_quarter_end[89]
+        assert dti.is_quarter_end[364]
+        assert not dti.is_year_end[0]
+        assert dti.is_year_end[364]
+
+        assert len(dti.year) == 365
+        assert len(dti.month) == 365
+        assert len(dti.day) == 365
+        assert len(dti.hour) == 365
+        assert len(dti.minute) == 365
+        assert len(dti.second) == 365
+        assert len(dti.microsecond) == 365
+        assert len(dti.dayofweek) == 365
+        assert len(dti.dayofyear) == 365
+        assert len(dti.isocalendar()) == 365
+        assert len(dti.quarter) == 365
+        assert len(dti.is_month_start) == 365
+        assert len(dti.is_month_end) == 365
+        assert len(dti.is_quarter_start) == 365
+        assert len(dti.is_quarter_end) == 365
+        assert len(dti.is_year_start) == 365
+        assert len(dti.is_year_end) == 365
+
+        dti.name = "name"
+
+        # non boolean accessors -> return Index
+        for accessor in DatetimeArray._field_ops:
+            res = getattr(dti, accessor)
+            assert len(res) == 365
+            assert isinstance(res, Index)
+            assert res.name == "name"
+
+        # boolean accessors -> return array
+        for accessor in DatetimeArray._bool_ops:
+            res = getattr(dti, accessor)
+            assert len(res) == 365
+            assert isinstance(res, np.ndarray)
+
+        # test boolean indexing
+        res = dti[dti.is_quarter_start]
+        exp = dti[[0, 90, 181, 273]]
+        tm.assert_index_equal(res, exp)
+        res = dti[dti.is_leap_year]
+        exp = DatetimeIndex([], freq="D", tz=dti.tz, name="name").as_unit("ns")
+        tm.assert_index_equal(res, exp)
+
+    def test_dti_is_year_quarter_start(self):
+        dti = date_range(freq="BQE-FEB", start=datetime(1998, 1, 1), periods=4)
+
+        assert sum(dti.is_quarter_start) == 0
+        assert sum(dti.is_quarter_end) == 4
+        assert sum(dti.is_year_start) == 0
+        assert sum(dti.is_year_end) == 1
+
+    def test_dti_is_month_start(self):
+        dti = DatetimeIndex(["2000-01-01", "2000-01-02", "2000-01-03"])
+
+        assert dti.is_month_start[0] == 1
+
+    def test_dti_is_month_start_custom(self):
+        # Ensure is_start/end accessors throw ValueError for CustomBusinessDay,
+        bday_egypt = offsets.CustomBusinessDay(weekmask="Sun Mon Tue Wed Thu")
+        dti = date_range(datetime(2013, 4, 30), periods=5, freq=bday_egypt)
+        msg = "Custom business days is not supported by is_month_start"
+        with pytest.raises(ValueError, match=msg):
+            dti.is_month_start