Add files using upload-large-folder tool

vllm/lib/python3.10/site-packages/pandas/tests/frame/methods/test_add_prefix_suffix.py

@@ -0,0 +1,49 @@
+import pytest
+
+from pandas import Index
+import pandas._testing as tm
+
+
+def test_add_prefix_suffix(float_frame):
+    with_prefix = float_frame.add_prefix("foo#")
+    expected = Index([f"foo#{c}" for c in float_frame.columns])
+    tm.assert_index_equal(with_prefix.columns, expected)
+
+    with_suffix = float_frame.add_suffix("#foo")
+    expected = Index([f"{c}#foo" for c in float_frame.columns])
+    tm.assert_index_equal(with_suffix.columns, expected)
+
+    with_pct_prefix = float_frame.add_prefix("%")
+    expected = Index([f"%{c}" for c in float_frame.columns])
+    tm.assert_index_equal(with_pct_prefix.columns, expected)
+
+    with_pct_suffix = float_frame.add_suffix("%")
+    expected = Index([f"{c}%" for c in float_frame.columns])
+    tm.assert_index_equal(with_pct_suffix.columns, expected)
+
+
+def test_add_prefix_suffix_axis(float_frame):
+    # GH 47819
+    with_prefix = float_frame.add_prefix("foo#", axis=0)
+    expected = Index([f"foo#{c}" for c in float_frame.index])
+    tm.assert_index_equal(with_prefix.index, expected)
+
+    with_prefix = float_frame.add_prefix("foo#", axis=1)
+    expected = Index([f"foo#{c}" for c in float_frame.columns])
+    tm.assert_index_equal(with_prefix.columns, expected)
+
+    with_pct_suffix = float_frame.add_suffix("#foo", axis=0)
+    expected = Index([f"{c}#foo" for c in float_frame.index])
+    tm.assert_index_equal(with_pct_suffix.index, expected)
+
+    with_pct_suffix = float_frame.add_suffix("#foo", axis=1)
+    expected = Index([f"{c}#foo" for c in float_frame.columns])
+    tm.assert_index_equal(with_pct_suffix.columns, expected)
+
+
+def test_add_prefix_suffix_invalid_axis(float_frame):
+    with pytest.raises(ValueError, match="No axis named 2 for object type DataFrame"):
+        float_frame.add_prefix("foo#", axis=2)
+
+    with pytest.raises(ValueError, match="No axis named 2 for object type DataFrame"):
+        float_frame.add_suffix("foo#", axis=2)

vllm/lib/python3.10/site-packages/pandas/tests/frame/methods/test_asof.py

@@ -0,0 +1,198 @@
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs import IncompatibleFrequency
+
+from pandas import (
+    DataFrame,
+    Period,
+    Series,
+    Timestamp,
+    date_range,
+    period_range,
+    to_datetime,
+)
+import pandas._testing as tm
+
+
+@pytest.fixture
+def date_range_frame():
+    """
+    Fixture for DataFrame of ints with date_range index
+
+    Columns are ['A', 'B'].
+    """
+    N = 50
+    rng = date_range("1/1/1990", periods=N, freq="53s")
+    return DataFrame({"A": np.arange(N), "B": np.arange(N)}, index=rng)
+
+
+class TestFrameAsof:
+    def test_basic(self, date_range_frame):
+        # Explicitly cast to float to avoid implicit cast when setting np.nan
+        df = date_range_frame.astype({"A": "float"})
+        N = 50
+        df.loc[df.index[15:30], "A"] = np.nan
+        dates = date_range("1/1/1990", periods=N * 3, freq="25s")
+
+        result = df.asof(dates)
+        assert result.notna().all(1).all()
+        lb = df.index[14]
+        ub = df.index[30]
+
+        dates = list(dates)
+
+        result = df.asof(dates)
+        assert result.notna().all(1).all()
+
+        mask = (result.index >= lb) & (result.index < ub)
+        rs = result[mask]
+        assert (rs == 14).all(1).all()
+
+    def test_subset(self, date_range_frame):
+        N = 10
+        # explicitly cast to float to avoid implicit upcast when setting to np.nan
+        df = date_range_frame.iloc[:N].copy().astype({"A": "float"})
+        df.loc[df.index[4:8], "A"] = np.nan
+        dates = date_range("1/1/1990", periods=N * 3, freq="25s")
+
+        # with a subset of A should be the same
+        result = df.asof(dates, subset="A")
+        expected = df.asof(dates)
+        tm.assert_frame_equal(result, expected)
+
+        # same with A/B
+        result = df.asof(dates, subset=["A", "B"])
+        expected = df.asof(dates)
+        tm.assert_frame_equal(result, expected)
+
+        # B gives df.asof
+        result = df.asof(dates, subset="B")
+        expected = df.resample("25s", closed="right").ffill().reindex(dates)
+        expected.iloc[20:] = 9
+        # no "missing", so "B" can retain int dtype (df["A"].dtype platform-dependent)
+        expected["B"] = expected["B"].astype(df["B"].dtype)
+
+        tm.assert_frame_equal(result, expected)
+
+    def test_missing(self, date_range_frame):
+        # GH 15118
+        # no match found - `where` value before earliest date in index
+        N = 10
+        # Cast to 'float64' to avoid upcast when introducing nan in df.asof
+        df = date_range_frame.iloc[:N].copy().astype("float64")
+
+        result = df.asof("1989-12-31")
+
+        expected = Series(
+            index=["A", "B"], name=Timestamp("1989-12-31"), dtype=np.float64
+        )
+        tm.assert_series_equal(result, expected)
+
+        result = df.asof(to_datetime(["1989-12-31"]))
+        expected = DataFrame(
+            index=to_datetime(["1989-12-31"]), columns=["A", "B"], dtype="float64"
+        )
+        tm.assert_frame_equal(result, expected)
+
+        # Check that we handle PeriodIndex correctly, dont end up with
+        #  period.ordinal for series name
+        df = df.to_period("D")
+        result = df.asof("1989-12-31")
+        assert isinstance(result.name, Period)
+
+    def test_asof_all_nans(self, frame_or_series):
+        # GH 15713
+        # DataFrame/Series is all nans
+        result = frame_or_series([np.nan]).asof([0])
+        expected = frame_or_series([np.nan])
+        tm.assert_equal(result, expected)
+
+    def test_all_nans(self, date_range_frame):
+        # GH 15713
+        # DataFrame is all nans
+
+        # testing non-default indexes, multiple inputs
+        N = 150
+        rng = date_range_frame.index
+        dates = date_range("1/1/1990", periods=N, freq="25s")
+        result = DataFrame(np.nan, index=rng, columns=["A"]).asof(dates)
+        expected = DataFrame(np.nan, index=dates, columns=["A"])
+        tm.assert_frame_equal(result, expected)
+
+        # testing multiple columns
+        dates = date_range("1/1/1990", periods=N, freq="25s")
+        result = DataFrame(np.nan, index=rng, columns=["A", "B", "C"]).asof(dates)
+        expected = DataFrame(np.nan, index=dates, columns=["A", "B", "C"])
+        tm.assert_frame_equal(result, expected)
+
+        # testing scalar input
+        result = DataFrame(np.nan, index=[1, 2], columns=["A", "B"]).asof([3])
+        expected = DataFrame(np.nan, index=[3], columns=["A", "B"])
+        tm.assert_frame_equal(result, expected)
+
+        result = DataFrame(np.nan, index=[1, 2], columns=["A", "B"]).asof(3)
+        expected = Series(np.nan, index=["A", "B"], name=3)
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "stamp,expected",
+        [
+            (
+                Timestamp("2018-01-01 23:22:43.325+00:00"),
+                Series(2, name=Timestamp("2018-01-01 23:22:43.325+00:00")),
+            ),
+            (
+                Timestamp("2018-01-01 22:33:20.682+01:00"),
+                Series(1, name=Timestamp("2018-01-01 22:33:20.682+01:00")),
+            ),
+        ],
+    )
+    def test_time_zone_aware_index(self, stamp, expected):
+        # GH21194
+        # Testing awareness of DataFrame index considering different
+        # UTC and timezone
+        df = DataFrame(
+            data=[1, 2],
+            index=[
+                Timestamp("2018-01-01 21:00:05.001+00:00"),
+                Timestamp("2018-01-01 22:35:10.550+00:00"),
+            ],
+        )
+
+        result = df.asof(stamp)
+        tm.assert_series_equal(result, expected)
+
+    def test_is_copy(self, date_range_frame):
+        # GH-27357, GH-30784: ensure the result of asof is an actual copy and
+        # doesn't track the parent dataframe / doesn't give SettingWithCopy warnings
+        df = date_range_frame.astype({"A": "float"})
+        N = 50
+        df.loc[df.index[15:30], "A"] = np.nan
+        dates = date_range("1/1/1990", periods=N * 3, freq="25s")
+
+        result = df.asof(dates)
+
+        with tm.assert_produces_warning(None):
+            result["C"] = 1
+
+    def test_asof_periodindex_mismatched_freq(self):
+        N = 50
+        rng = period_range("1/1/1990", periods=N, freq="h")
+        df = DataFrame(np.random.default_rng(2).standard_normal(N), index=rng)
+
+        # Mismatched freq
+        msg = "Input has different freq"
+        with pytest.raises(IncompatibleFrequency, match=msg):
+            df.asof(rng.asfreq("D"))
+
+    def test_asof_preserves_bool_dtype(self):
+        # GH#16063 was casting bools to floats
+        dti = date_range("2017-01-01", freq="MS", periods=4)
+        ser = Series([True, False, True], index=dti[:-1])
+
+        ts = dti[-1]
+        res = ser.asof([ts])
+
+        expected = Series([True], index=[ts])
+        tm.assert_series_equal(res, expected)

vllm/lib/python3.10/site-packages/pandas/tests/frame/methods/test_at_time.py

@@ -0,0 +1,132 @@
+from datetime import time
+
+import numpy as np
+import pytest
+import pytz
+
+from pandas._libs.tslibs import timezones
+
+from pandas import (
+    DataFrame,
+    date_range,
+)
+import pandas._testing as tm
+
+
+class TestAtTime:
+    @pytest.mark.parametrize("tzstr", ["US/Eastern", "dateutil/US/Eastern"])
+    def test_localized_at_time(self, tzstr, frame_or_series):
+        tz = timezones.maybe_get_tz(tzstr)
+
+        rng = date_range("4/16/2012", "5/1/2012", freq="h")
+        ts = frame_or_series(
+            np.random.default_rng(2).standard_normal(len(rng)), index=rng
+        )
+
+        ts_local = ts.tz_localize(tzstr)
+
+        result = ts_local.at_time(time(10, 0))
+        expected = ts.at_time(time(10, 0)).tz_localize(tzstr)
+        tm.assert_equal(result, expected)
+        assert timezones.tz_compare(result.index.tz, tz)
+
+    def test_at_time(self, frame_or_series):
+        rng = date_range("1/1/2000", "1/5/2000", freq="5min")
+        ts = DataFrame(
+            np.random.default_rng(2).standard_normal((len(rng), 2)), index=rng
+        )
+        ts = tm.get_obj(ts, frame_or_series)
+        rs = ts.at_time(rng[1])
+        assert (rs.index.hour == rng[1].hour).all()
+        assert (rs.index.minute == rng[1].minute).all()
+        assert (rs.index.second == rng[1].second).all()
+
+        result = ts.at_time("9:30")
+        expected = ts.at_time(time(9, 30))
+        tm.assert_equal(result, expected)
+
+    def test_at_time_midnight(self, frame_or_series):
+        # midnight, everything
+        rng = date_range("1/1/2000", "1/31/2000")
+        ts = DataFrame(
+            np.random.default_rng(2).standard_normal((len(rng), 3)), index=rng
+        )
+        ts = tm.get_obj(ts, frame_or_series)
+
+        result = ts.at_time(time(0, 0))
+        tm.assert_equal(result, ts)
+
+    def test_at_time_nonexistent(self, frame_or_series):
+        # time doesn't exist
+        rng = date_range("1/1/2012", freq="23Min", periods=384)
+        ts = DataFrame(np.random.default_rng(2).standard_normal(len(rng)), rng)
+        ts = tm.get_obj(ts, frame_or_series)
+        rs = ts.at_time("16:00")
+        assert len(rs) == 0
+
+    @pytest.mark.parametrize(
+        "hour", ["1:00", "1:00AM", time(1), time(1, tzinfo=pytz.UTC)]
+    )
+    def test_at_time_errors(self, hour):
+        # GH#24043
+        dti = date_range("2018", periods=3, freq="h")
+        df = DataFrame(list(range(len(dti))), index=dti)
+        if getattr(hour, "tzinfo", None) is None:
+            result = df.at_time(hour)
+            expected = df.iloc[1:2]
+            tm.assert_frame_equal(result, expected)
+        else:
+            with pytest.raises(ValueError, match="Index must be timezone"):
+                df.at_time(hour)
+
+    def test_at_time_tz(self):
+        # GH#24043
+        dti = date_range("2018", periods=3, freq="h", tz="US/Pacific")
+        df = DataFrame(list(range(len(dti))), index=dti)
+        result = df.at_time(time(4, tzinfo=pytz.timezone("US/Eastern")))
+        expected = df.iloc[1:2]
+        tm.assert_frame_equal(result, expected)
+
+    def test_at_time_raises(self, frame_or_series):
+        # GH#20725
+        obj = DataFrame([[1, 2, 3], [4, 5, 6]])
+        obj = tm.get_obj(obj, frame_or_series)
+        msg = "Index must be DatetimeIndex"
+        with pytest.raises(TypeError, match=msg):  # index is not a DatetimeIndex
+            obj.at_time("00:00")
+
+    @pytest.mark.parametrize("axis", ["index", "columns", 0, 1])
+    def test_at_time_axis(self, axis):
+        # issue 8839
+        rng = date_range("1/1/2000", "1/5/2000", freq="5min")
+        ts = DataFrame(np.random.default_rng(2).standard_normal((len(rng), len(rng))))
+        ts.index, ts.columns = rng, rng
+
+        indices = rng[(rng.hour == 9) & (rng.minute == 30) & (rng.second == 0)]
+
+        if axis in ["index", 0]:
+            expected = ts.loc[indices, :]
+        elif axis in ["columns", 1]:
+            expected = ts.loc[:, indices]
+
+        result = ts.at_time("9:30", axis=axis)
+
+        # Without clearing freq, result has freq 1440T and expected 5T
+        result.index = result.index._with_freq(None)
+        expected.index = expected.index._with_freq(None)
+        tm.assert_frame_equal(result, expected)
+
+    def test_at_time_datetimeindex(self):
+        index = date_range("2012-01-01", "2012-01-05", freq="30min")
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((len(index), 5)), index=index
+        )
+        akey = time(12, 0, 0)
+        ainds = [24, 72, 120, 168]
+
+        result = df.at_time(akey)
+        expected = df.loc[akey]
+        expected2 = df.iloc[ainds]
+        tm.assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected2)
+        assert len(result) == 4