diff --git a/pandas/tests/arithmetic/test_categorical.py b/pandas/tests/arithmetic/test_categorical.py new file mode 100644 index 0000000000000..a978f763fbaaa --- /dev/null +++ b/pandas/tests/arithmetic/test_categorical.py @@ -0,0 +1,12 @@ +import numpy as np + +from pandas import Categorical, Series +import pandas._testing as tm + + +class TestCategoricalComparisons: + def test_categorical_nan_equality(self): + cat = Series(Categorical(["a", "b", "c", np.nan])) + expected = Series([True, True, True, False]) + result = cat == cat + tm.assert_series_equal(result, expected) diff --git a/pandas/tests/frame/methods/test_asfreq.py b/pandas/tests/frame/methods/test_asfreq.py index 40b0ec0c0d811..cdcd922949bcf 100644 --- a/pandas/tests/frame/methods/test_asfreq.py +++ b/pandas/tests/frame/methods/test_asfreq.py @@ -2,13 +2,31 @@ import numpy as np -from pandas import DataFrame, DatetimeIndex, Series, date_range +from pandas import DataFrame, DatetimeIndex, Series, date_range, to_datetime import pandas._testing as tm from pandas.tseries import offsets class TestAsFreq: + def test_asfreq_resample_set_correct_freq(self): + # GH#5613 + # we test if .asfreq() and .resample() set the correct value for .freq + df = DataFrame( + {"date": ["2012-01-01", "2012-01-02", "2012-01-03"], "col": [1, 2, 3]} + ) + df = df.set_index(to_datetime(df.date)) + + # testing the settings before calling .asfreq() and .resample() + assert df.index.freq is None + assert df.index.inferred_freq == "D" + + # does .asfreq() set .freq correctly? + assert df.asfreq("D").index.freq == "D" + + # does .resample() set .freq correctly? + assert df.resample("D").asfreq().index.freq == "D" + def test_asfreq(self, datetime_frame): offset_monthly = datetime_frame.asfreq(offsets.BMonthEnd()) rule_monthly = datetime_frame.asfreq("BM") diff --git a/pandas/tests/indexes/datetimes/test_indexing.py b/pandas/tests/indexes/datetimes/test_indexing.py index cb12365f38605..e0506df5cd939 100644 --- a/pandas/tests/indexes/datetimes/test_indexing.py +++ b/pandas/tests/indexes/datetimes/test_indexing.py @@ -618,6 +618,16 @@ def test_get_indexer_out_of_bounds_date(self, target, positions): expected = np.array(positions, dtype=np.intp) tm.assert_numpy_array_equal(result, expected) + def test_get_indexer_pad_requires_monotonicity(self): + rng = date_range("1/1/2000", "3/1/2000", freq="B") + + # neither monotonic increasing or decreasing + rng2 = rng[[1, 0, 2]] + + msg = "index must be monotonic increasing or decreasing" + with pytest.raises(ValueError, match=msg): + rng2.get_indexer(rng, method="pad") + class TestMaybeCastSliceBound: def test_maybe_cast_slice_bounds_empty(self): diff --git a/pandas/tests/series/methods/test_convert.py b/pandas/tests/series/methods/test_convert.py new file mode 100644 index 0000000000000..b213e4a6c4c8a --- /dev/null +++ b/pandas/tests/series/methods/test_convert.py @@ -0,0 +1,203 @@ +from datetime import datetime + +import numpy as np +import pytest + +from pandas import NaT, Series, Timestamp +import pandas._testing as tm + + +class TestConvert: + def test_convert(self): + # GH#10265 + # Tests: All to nans, coerce, true + # Test coercion returns correct type + ser = Series(["a", "b", "c"]) + results = ser._convert(datetime=True, coerce=True) + expected = Series([NaT] * 3) + tm.assert_series_equal(results, expected) + + results = ser._convert(numeric=True, coerce=True) + expected = Series([np.nan] * 3) + tm.assert_series_equal(results, expected) + + expected = Series([NaT] * 3, dtype=np.dtype("m8[ns]")) + results = ser._convert(timedelta=True, coerce=True) + tm.assert_series_equal(results, expected) + + dt = datetime(2001, 1, 1, 0, 0) + td = dt - datetime(2000, 1, 1, 0, 0) + + # Test coercion with mixed types + ser = Series(["a", "3.1415", dt, td]) + results = ser._convert(datetime=True, coerce=True) + expected = Series([NaT, NaT, dt, NaT]) + tm.assert_series_equal(results, expected) + + results = ser._convert(numeric=True, coerce=True) + expected = Series([np.nan, 3.1415, np.nan, np.nan]) + tm.assert_series_equal(results, expected) + + results = ser._convert(timedelta=True, coerce=True) + expected = Series([NaT, NaT, NaT, td], dtype=np.dtype("m8[ns]")) + tm.assert_series_equal(results, expected) + + # Test standard conversion returns original + results = ser._convert(datetime=True) + tm.assert_series_equal(results, ser) + results = ser._convert(numeric=True) + expected = Series([np.nan, 3.1415, np.nan, np.nan]) + tm.assert_series_equal(results, expected) + results = ser._convert(timedelta=True) + tm.assert_series_equal(results, ser) + + # test pass-through and non-conversion when other types selected + ser = Series(["1.0", "2.0", "3.0"]) + results = ser._convert(datetime=True, numeric=True, timedelta=True) + expected = Series([1.0, 2.0, 3.0]) + tm.assert_series_equal(results, expected) + results = ser._convert(True, False, True) + tm.assert_series_equal(results, ser) + + ser = Series( + [datetime(2001, 1, 1, 0, 0), datetime(2001, 1, 1, 0, 0)], dtype="O" + ) + results = ser._convert(datetime=True, numeric=True, timedelta=True) + expected = Series([datetime(2001, 1, 1, 0, 0), datetime(2001, 1, 1, 0, 0)]) + tm.assert_series_equal(results, expected) + results = ser._convert(datetime=False, numeric=True, timedelta=True) + tm.assert_series_equal(results, ser) + + td = datetime(2001, 1, 1, 0, 0) - datetime(2000, 1, 1, 0, 0) + ser = Series([td, td], dtype="O") + results = ser._convert(datetime=True, numeric=True, timedelta=True) + expected = Series([td, td]) + tm.assert_series_equal(results, expected) + results = ser._convert(True, True, False) + tm.assert_series_equal(results, ser) + + ser = Series([1.0, 2, 3], index=["a", "b", "c"]) + result = ser._convert(numeric=True) + tm.assert_series_equal(result, ser) + + # force numeric conversion + res = ser.copy().astype("O") + res["a"] = "1" + result = res._convert(numeric=True) + tm.assert_series_equal(result, ser) + + res = ser.copy().astype("O") + res["a"] = "1." + result = res._convert(numeric=True) + tm.assert_series_equal(result, ser) + + res = ser.copy().astype("O") + res["a"] = "garbled" + result = res._convert(numeric=True) + expected = ser.copy() + expected["a"] = np.nan + tm.assert_series_equal(result, expected) + + # GH 4119, not converting a mixed type (e.g.floats and object) + ser = Series([1, "na", 3, 4]) + result = ser._convert(datetime=True, numeric=True) + expected = Series([1, np.nan, 3, 4]) + tm.assert_series_equal(result, expected) + + ser = Series([1, "", 3, 4]) + result = ser._convert(datetime=True, numeric=True) + tm.assert_series_equal(result, expected) + + # dates + ser = Series( + [ + datetime(2001, 1, 1, 0, 0), + datetime(2001, 1, 2, 0, 0), + datetime(2001, 1, 3, 0, 0), + ] + ) + s2 = Series( + [ + datetime(2001, 1, 1, 0, 0), + datetime(2001, 1, 2, 0, 0), + datetime(2001, 1, 3, 0, 0), + "foo", + 1.0, + 1, + Timestamp("20010104"), + "20010105", + ], + dtype="O", + ) + + result = ser._convert(datetime=True) + expected = Series( + [Timestamp("20010101"), Timestamp("20010102"), Timestamp("20010103")], + dtype="M8[ns]", + ) + tm.assert_series_equal(result, expected) + + result = ser._convert(datetime=True, coerce=True) + tm.assert_series_equal(result, expected) + + expected = Series( + [ + Timestamp("20010101"), + Timestamp("20010102"), + Timestamp("20010103"), + NaT, + NaT, + NaT, + Timestamp("20010104"), + Timestamp("20010105"), + ], + dtype="M8[ns]", + ) + result = s2._convert(datetime=True, numeric=False, timedelta=False, coerce=True) + tm.assert_series_equal(result, expected) + result = s2._convert(datetime=True, coerce=True) + tm.assert_series_equal(result, expected) + + ser = Series(["foo", "bar", 1, 1.0], dtype="O") + result = ser._convert(datetime=True, coerce=True) + expected = Series([NaT] * 2 + [Timestamp(1)] * 2) + tm.assert_series_equal(result, expected) + + # preserver if non-object + ser = Series([1], dtype="float32") + result = ser._convert(datetime=True, coerce=True) + tm.assert_series_equal(result, ser) + + # FIXME: dont leave commented-out + # res = ser.copy() + # r[0] = np.nan + # result = res._convert(convert_dates=True,convert_numeric=False) + # assert result.dtype == 'M8[ns]' + + # dateutil parses some single letters into today's value as a date + expected = Series([NaT]) + for x in "abcdefghijklmnopqrstuvwxyz": + ser = Series([x]) + result = ser._convert(datetime=True, coerce=True) + tm.assert_series_equal(result, expected) + ser = Series([x.upper()]) + result = ser._convert(datetime=True, coerce=True) + tm.assert_series_equal(result, expected) + + def test_convert_no_arg_error(self): + ser = Series(["1.0", "2"]) + msg = r"At least one of datetime, numeric or timedelta must be True\." + with pytest.raises(ValueError, match=msg): + ser._convert() + + def test_convert_preserve_bool(self): + ser = Series([1, True, 3, 5], dtype=object) + res = ser._convert(datetime=True, numeric=True) + expected = Series([1, 1, 3, 5], dtype="i8") + tm.assert_series_equal(res, expected) + + def test_convert_preserve_all_bool(self): + ser = Series([False, True, False, False], dtype=object) + res = ser._convert(datetime=True, numeric=True) + expected = Series([False, True, False, False], dtype=bool) + tm.assert_series_equal(res, expected) diff --git a/pandas/tests/series/methods/test_dropna.py b/pandas/tests/series/methods/test_dropna.py new file mode 100644 index 0000000000000..f56230daea190 --- /dev/null +++ b/pandas/tests/series/methods/test_dropna.py @@ -0,0 +1,96 @@ +import numpy as np +import pytest + +from pandas import DatetimeIndex, IntervalIndex, NaT, Period, Series, Timestamp +import pandas._testing as tm + + +class TestDropna: + def test_dropna_empty(self): + ser = Series([], dtype=object) + + assert len(ser.dropna()) == 0 + return_value = ser.dropna(inplace=True) + assert return_value is None + assert len(ser) == 0 + + # invalid axis + msg = "No axis named 1 for object type Series" + with pytest.raises(ValueError, match=msg): + ser.dropna(axis=1) + + def test_dropna_preserve_name(self, datetime_series): + datetime_series[:5] = np.nan + result = datetime_series.dropna() + assert result.name == datetime_series.name + name = datetime_series.name + ts = datetime_series.copy() + return_value = ts.dropna(inplace=True) + assert return_value is None + assert ts.name == name + + def test_dropna_no_nan(self): + for ser in [ + Series([1, 2, 3], name="x"), + Series([False, True, False], name="x"), + ]: + + result = ser.dropna() + tm.assert_series_equal(result, ser) + assert result is not ser + + s2 = ser.copy() + return_value = s2.dropna(inplace=True) + assert return_value is None + tm.assert_series_equal(s2, ser) + + def test_dropna_intervals(self): + ser = Series( + [np.nan, 1, 2, 3], + IntervalIndex.from_arrays([np.nan, 0, 1, 2], [np.nan, 1, 2, 3]), + ) + + result = ser.dropna() + expected = ser.iloc[1:] + tm.assert_series_equal(result, expected) + + def test_dropna_period_dtype(self): + # GH#13737 + ser = Series([Period("2011-01", freq="M"), Period("NaT", freq="M")]) + result = ser.dropna() + expected = Series([Period("2011-01", freq="M")]) + + tm.assert_series_equal(result, expected) + + def test_datetime64_tz_dropna(self): + # DatetimeBlock + ser = Series( + [ + Timestamp("2011-01-01 10:00"), + NaT, + Timestamp("2011-01-03 10:00"), + NaT, + ] + ) + result = ser.dropna() + expected = Series( + [Timestamp("2011-01-01 10:00"), Timestamp("2011-01-03 10:00")], index=[0, 2] + ) + tm.assert_series_equal(result, expected) + + # DatetimeBlockTZ + idx = DatetimeIndex( + ["2011-01-01 10:00", NaT, "2011-01-03 10:00", NaT], tz="Asia/Tokyo" + ) + ser = Series(idx) + assert ser.dtype == "datetime64[ns, Asia/Tokyo]" + result = ser.dropna() + expected = Series( + [ + Timestamp("2011-01-01 10:00", tz="Asia/Tokyo"), + Timestamp("2011-01-03 10:00", tz="Asia/Tokyo"), + ], + index=[0, 2], + ) + assert result.dtype == "datetime64[ns, Asia/Tokyo]" + tm.assert_series_equal(result, expected) diff --git a/pandas/tests/series/methods/test_fillna.py b/pandas/tests/series/methods/test_fillna.py index 02214d66347e1..d45486b9bdb29 100644 --- a/pandas/tests/series/methods/test_fillna.py +++ b/pandas/tests/series/methods/test_fillna.py @@ -19,6 +19,43 @@ class TestSeriesFillNA: + def test_fillna_nat(self): + series = Series([0, 1, 2, NaT.value], dtype="M8[ns]") + + filled = series.fillna(method="pad") + filled2 = series.fillna(value=series.values[2]) + + expected = series.copy() + expected.values[3] = expected.values[2] + + tm.assert_series_equal(filled, expected) + tm.assert_series_equal(filled2, expected) + + df = DataFrame({"A": series}) + filled = df.fillna(method="pad") + filled2 = df.fillna(value=series.values[2]) + expected = DataFrame({"A": expected}) + tm.assert_frame_equal(filled, expected) + tm.assert_frame_equal(filled2, expected) + + series = Series([NaT.value, 0, 1, 2], dtype="M8[ns]") + + filled = series.fillna(method="bfill") + filled2 = series.fillna(value=series[1]) + + expected = series.copy() + expected[0] = expected[1] + + tm.assert_series_equal(filled, expected) + tm.assert_series_equal(filled2, expected) + + df = DataFrame({"A": series}) + filled = df.fillna(method="bfill") + filled2 = df.fillna(value=series[1]) + expected = DataFrame({"A": expected}) + tm.assert_frame_equal(filled, expected) + tm.assert_frame_equal(filled2, expected) + def test_fillna(self, datetime_series): ts = Series([0.0, 1.0, 2.0, 3.0, 4.0], index=tm.makeDateIndex(5)) diff --git a/pandas/tests/series/test_constructors.py b/pandas/tests/series/test_constructors.py index efa2ab0f22442..1958e44b6d1a3 100644 --- a/pandas/tests/series/test_constructors.py +++ b/pandas/tests/series/test_constructors.py @@ -19,6 +19,7 @@ from pandas import ( Categorical, DataFrame, + DatetimeIndex, Index, Interval, IntervalIndex, @@ -1507,3 +1508,22 @@ def test_construction_from_large_int_scalar_no_overflow(self): result = Series(n, index=[0]) expected = Series(n) tm.assert_series_equal(result, expected) + + def test_constructor_list_of_periods_infers_period_dtype(self): + series = Series(list(period_range("2000-01-01", periods=10, freq="D"))) + assert series.dtype == "Period[D]" + + series = Series( + [pd.Period("2011-01-01", freq="D"), pd.Period("2011-02-01", freq="D")] + ) + assert series.dtype == "Period[D]" + + +class TestSeriesConstructorIndexCoercion: + def test_series_constructor_datetimelike_index_coercion(self): + idx = tm.makeDateIndex(10000) + with tm.assert_produces_warning(FutureWarning): + ser = Series(np.random.randn(len(idx)), idx.astype(object)) + with tm.assert_produces_warning(FutureWarning): + assert ser.index.is_all_dates + assert isinstance(ser.index, DatetimeIndex) diff --git a/pandas/tests/series/test_dt_accessor.py b/pandas/tests/series/test_dt_accessor.py index 0e31ffcb30b93..2f30c0621cc06 100644 --- a/pandas/tests/series/test_dt_accessor.py +++ b/pandas/tests/series/test_dt_accessor.py @@ -16,6 +16,7 @@ DataFrame, DatetimeIndex, Index, + Period, PeriodIndex, Series, TimedeltaIndex, @@ -675,6 +676,45 @@ def test_isocalendar(self, input_series, expected_output): tm.assert_frame_equal(result, expected_frame) +class TestSeriesPeriodValuesDtAccessor: + @pytest.mark.parametrize( + "input_vals", + [ + [Period("2016-01", freq="M"), Period("2016-02", freq="M")], + [Period("2016-01-01", freq="D"), Period("2016-01-02", freq="D")], + [ + Period("2016-01-01 00:00:00", freq="H"), + Period("2016-01-01 01:00:00", freq="H"), + ], + [ + Period("2016-01-01 00:00:00", freq="M"), + Period("2016-01-01 00:01:00", freq="M"), + ], + [ + Period("2016-01-01 00:00:00", freq="S"), + Period("2016-01-01 00:00:01", freq="S"), + ], + ], + ) + def test_end_time_timevalues(self, input_vals): + # GH#17157 + # Check that the time part of the Period is adjusted by end_time + # when using the dt accessor on a Series + input_vals = PeriodArray._from_sequence(np.asarray(input_vals)) + + s = Series(input_vals) + result = s.dt.end_time + expected = s.apply(lambda x: x.end_time) + tm.assert_series_equal(result, expected) + + @pytest.mark.parametrize("input_vals", [("2001"), ("NaT")]) + def test_to_period(self, input_vals): + # GH#21205 + expected = Series([input_vals], dtype="Period[D]") + result = Series([input_vals], dtype="datetime64[ns]").dt.to_period("D") + tm.assert_series_equal(result, expected) + + def test_week_and_weekofyear_are_deprecated(): # GH#33595 Deprecate week and weekofyear series = pd.to_datetime(Series(["2020-01-01"])) diff --git a/pandas/tests/series/test_internals.py b/pandas/tests/series/test_internals.py index 488bd120ac405..be106e8b1fef4 100644 --- a/pandas/tests/series/test_internals.py +++ b/pandas/tests/series/test_internals.py @@ -1,208 +1,12 @@ -from datetime import datetime - import numpy as np -import pytest import pandas as pd -from pandas import NaT, Series, Timestamp +from pandas import Series import pandas._testing as tm from pandas.core.internals.blocks import IntBlock class TestSeriesInternals: - - # GH 10265 - def test_convert(self): - # Tests: All to nans, coerce, true - # Test coercion returns correct type - s = Series(["a", "b", "c"]) - results = s._convert(datetime=True, coerce=True) - expected = Series([NaT] * 3) - tm.assert_series_equal(results, expected) - - results = s._convert(numeric=True, coerce=True) - expected = Series([np.nan] * 3) - tm.assert_series_equal(results, expected) - - expected = Series([NaT] * 3, dtype=np.dtype("m8[ns]")) - results = s._convert(timedelta=True, coerce=True) - tm.assert_series_equal(results, expected) - - dt = datetime(2001, 1, 1, 0, 0) - td = dt - datetime(2000, 1, 1, 0, 0) - - # Test coercion with mixed types - s = Series(["a", "3.1415", dt, td]) - results = s._convert(datetime=True, coerce=True) - expected = Series([NaT, NaT, dt, NaT]) - tm.assert_series_equal(results, expected) - - results = s._convert(numeric=True, coerce=True) - expected = Series([np.nan, 3.1415, np.nan, np.nan]) - tm.assert_series_equal(results, expected) - - results = s._convert(timedelta=True, coerce=True) - expected = Series([NaT, NaT, NaT, td], dtype=np.dtype("m8[ns]")) - tm.assert_series_equal(results, expected) - - # Test standard conversion returns original - results = s._convert(datetime=True) - tm.assert_series_equal(results, s) - results = s._convert(numeric=True) - expected = Series([np.nan, 3.1415, np.nan, np.nan]) - tm.assert_series_equal(results, expected) - results = s._convert(timedelta=True) - tm.assert_series_equal(results, s) - - # test pass-through and non-conversion when other types selected - s = Series(["1.0", "2.0", "3.0"]) - results = s._convert(datetime=True, numeric=True, timedelta=True) - expected = Series([1.0, 2.0, 3.0]) - tm.assert_series_equal(results, expected) - results = s._convert(True, False, True) - tm.assert_series_equal(results, s) - - s = Series([datetime(2001, 1, 1, 0, 0), datetime(2001, 1, 1, 0, 0)], dtype="O") - results = s._convert(datetime=True, numeric=True, timedelta=True) - expected = Series([datetime(2001, 1, 1, 0, 0), datetime(2001, 1, 1, 0, 0)]) - tm.assert_series_equal(results, expected) - results = s._convert(datetime=False, numeric=True, timedelta=True) - tm.assert_series_equal(results, s) - - td = datetime(2001, 1, 1, 0, 0) - datetime(2000, 1, 1, 0, 0) - s = Series([td, td], dtype="O") - results = s._convert(datetime=True, numeric=True, timedelta=True) - expected = Series([td, td]) - tm.assert_series_equal(results, expected) - results = s._convert(True, True, False) - tm.assert_series_equal(results, s) - - s = Series([1.0, 2, 3], index=["a", "b", "c"]) - result = s._convert(numeric=True) - tm.assert_series_equal(result, s) - - # force numeric conversion - r = s.copy().astype("O") - r["a"] = "1" - result = r._convert(numeric=True) - tm.assert_series_equal(result, s) - - r = s.copy().astype("O") - r["a"] = "1." - result = r._convert(numeric=True) - tm.assert_series_equal(result, s) - - r = s.copy().astype("O") - r["a"] = "garbled" - result = r._convert(numeric=True) - expected = s.copy() - expected["a"] = np.nan - tm.assert_series_equal(result, expected) - - # GH 4119, not converting a mixed type (e.g.floats and object) - s = Series([1, "na", 3, 4]) - result = s._convert(datetime=True, numeric=True) - expected = Series([1, np.nan, 3, 4]) - tm.assert_series_equal(result, expected) - - s = Series([1, "", 3, 4]) - result = s._convert(datetime=True, numeric=True) - tm.assert_series_equal(result, expected) - - # dates - s = Series( - [ - datetime(2001, 1, 1, 0, 0), - datetime(2001, 1, 2, 0, 0), - datetime(2001, 1, 3, 0, 0), - ] - ) - s2 = Series( - [ - datetime(2001, 1, 1, 0, 0), - datetime(2001, 1, 2, 0, 0), - datetime(2001, 1, 3, 0, 0), - "foo", - 1.0, - 1, - Timestamp("20010104"), - "20010105", - ], - dtype="O", - ) - - result = s._convert(datetime=True) - expected = Series( - [Timestamp("20010101"), Timestamp("20010102"), Timestamp("20010103")], - dtype="M8[ns]", - ) - tm.assert_series_equal(result, expected) - - result = s._convert(datetime=True, coerce=True) - tm.assert_series_equal(result, expected) - - expected = Series( - [ - Timestamp("20010101"), - Timestamp("20010102"), - Timestamp("20010103"), - NaT, - NaT, - NaT, - Timestamp("20010104"), - Timestamp("20010105"), - ], - dtype="M8[ns]", - ) - result = s2._convert(datetime=True, numeric=False, timedelta=False, coerce=True) - tm.assert_series_equal(result, expected) - result = s2._convert(datetime=True, coerce=True) - tm.assert_series_equal(result, expected) - - s = Series(["foo", "bar", 1, 1.0], dtype="O") - result = s._convert(datetime=True, coerce=True) - expected = Series([NaT] * 2 + [Timestamp(1)] * 2) - tm.assert_series_equal(result, expected) - - # preserver if non-object - s = Series([1], dtype="float32") - result = s._convert(datetime=True, coerce=True) - tm.assert_series_equal(result, s) - - # FIXME: dont leave commented-out - # r = s.copy() - # r[0] = np.nan - # result = r._convert(convert_dates=True,convert_numeric=False) - # assert result.dtype == 'M8[ns]' - - # dateutil parses some single letters into today's value as a date - expected = Series([NaT]) - for x in "abcdefghijklmnopqrstuvwxyz": - s = Series([x]) - result = s._convert(datetime=True, coerce=True) - tm.assert_series_equal(result, expected) - s = Series([x.upper()]) - result = s._convert(datetime=True, coerce=True) - tm.assert_series_equal(result, expected) - - def test_convert_no_arg_error(self): - s = Series(["1.0", "2"]) - msg = r"At least one of datetime, numeric or timedelta must be True\." - with pytest.raises(ValueError, match=msg): - s._convert() - - def test_convert_preserve_bool(self): - s = Series([1, True, 3, 5], dtype=object) - r = s._convert(datetime=True, numeric=True) - e = Series([1, 1, 3, 5], dtype="i8") - tm.assert_series_equal(r, e) - - def test_convert_preserve_all_bool(self): - s = Series([False, True, False, False], dtype=object) - r = s._convert(datetime=True, numeric=True) - e = Series([False, True, False, False], dtype=bool) - tm.assert_series_equal(r, e) - def test_constructor_no_pandas_array(self): ser = Series([1, 2, 3]) result = Series(ser.array) diff --git a/pandas/tests/series/test_missing.py b/pandas/tests/series/test_missing.py index 6d8d0703acdb5..f601d7cb655b3 100644 --- a/pandas/tests/series/test_missing.py +++ b/pandas/tests/series/test_missing.py @@ -1,32 +1,15 @@ from datetime import timedelta import numpy as np -import pytest from pandas._libs import iNaT import pandas as pd -from pandas import ( - Categorical, - DataFrame, - Index, - IntervalIndex, - NaT, - Series, - Timestamp, - date_range, - isna, -) +from pandas import Categorical, Index, NaT, Series, isna import pandas._testing as tm class TestSeriesMissingData: - def test_categorical_nan_equality(self): - cat = Series(Categorical(["a", "b", "c", np.nan])) - exp = Series([True, True, True, False]) - res = cat == cat - tm.assert_series_equal(res, exp) - def test_categorical_nan_handling(self): # NaNs are represented as -1 in labels @@ -36,43 +19,6 @@ def test_categorical_nan_handling(self): s.values.codes, np.array([0, 1, -1, 0], dtype=np.int8) ) - def test_fillna_nat(self): - series = Series([0, 1, 2, iNaT], dtype="M8[ns]") - - filled = series.fillna(method="pad") - filled2 = series.fillna(value=series.values[2]) - - expected = series.copy() - expected.values[3] = expected.values[2] - - tm.assert_series_equal(filled, expected) - tm.assert_series_equal(filled2, expected) - - df = DataFrame({"A": series}) - filled = df.fillna(method="pad") - filled2 = df.fillna(value=series.values[2]) - expected = DataFrame({"A": expected}) - tm.assert_frame_equal(filled, expected) - tm.assert_frame_equal(filled2, expected) - - series = Series([iNaT, 0, 1, 2], dtype="M8[ns]") - - filled = series.fillna(method="bfill") - filled2 = series.fillna(value=series[1]) - - expected = series.copy() - expected[0] = expected[1] - - tm.assert_series_equal(filled, expected) - tm.assert_series_equal(filled2, expected) - - df = DataFrame({"A": series}) - filled = df.fillna(method="bfill") - filled2 = df.fillna(value=series[1]) - expected = DataFrame({"A": expected}) - tm.assert_frame_equal(filled, expected) - tm.assert_frame_equal(filled2, expected) - def test_isna_for_inf(self): s = Series(["a", np.inf, np.nan, pd.NA, 1.0]) with pd.option_context("mode.use_inf_as_na", True): @@ -136,74 +82,6 @@ def test_timedelta64_nan(self): # expected = (datetime_series >= -0.5) & (datetime_series <= 0.5) # tm.assert_series_equal(selector, expected) - def test_dropna_empty(self): - s = Series([], dtype=object) - - assert len(s.dropna()) == 0 - return_value = s.dropna(inplace=True) - assert return_value is None - assert len(s) == 0 - - # invalid axis - msg = "No axis named 1 for object type Series" - with pytest.raises(ValueError, match=msg): - s.dropna(axis=1) - - def test_datetime64_tz_dropna(self): - # DatetimeBlock - s = Series( - [ - Timestamp("2011-01-01 10:00"), - pd.NaT, - Timestamp("2011-01-03 10:00"), - pd.NaT, - ] - ) - result = s.dropna() - expected = Series( - [Timestamp("2011-01-01 10:00"), Timestamp("2011-01-03 10:00")], index=[0, 2] - ) - tm.assert_series_equal(result, expected) - - # DatetimeBlockTZ - idx = pd.DatetimeIndex( - ["2011-01-01 10:00", pd.NaT, "2011-01-03 10:00", pd.NaT], tz="Asia/Tokyo" - ) - s = Series(idx) - assert s.dtype == "datetime64[ns, Asia/Tokyo]" - result = s.dropna() - expected = Series( - [ - Timestamp("2011-01-01 10:00", tz="Asia/Tokyo"), - Timestamp("2011-01-03 10:00", tz="Asia/Tokyo"), - ], - index=[0, 2], - ) - assert result.dtype == "datetime64[ns, Asia/Tokyo]" - tm.assert_series_equal(result, expected) - - def test_dropna_no_nan(self): - for s in [Series([1, 2, 3], name="x"), Series([False, True, False], name="x")]: - - result = s.dropna() - tm.assert_series_equal(result, s) - assert result is not s - - s2 = s.copy() - return_value = s2.dropna(inplace=True) - assert return_value is None - tm.assert_series_equal(s2, s) - - def test_dropna_intervals(self): - s = Series( - [np.nan, 1, 2, 3], - IntervalIndex.from_arrays([np.nan, 0, 1, 2], [np.nan, 1, 2, 3]), - ) - - result = s.dropna() - expected = s.iloc[1:] - tm.assert_series_equal(result, expected) - def test_valid(self, datetime_series): ts = datetime_series.copy() ts.index = ts.index._with_freq(None) @@ -231,23 +109,3 @@ def test_notna(self): ser = Series(["hi", "", np.nan]) expected = Series([True, True, False]) tm.assert_series_equal(ser.notna(), expected) - - def test_pad_require_monotonicity(self): - rng = date_range("1/1/2000", "3/1/2000", freq="B") - - # neither monotonic increasing or decreasing - rng2 = rng[[1, 0, 2]] - - msg = "index must be monotonic increasing or decreasing" - with pytest.raises(ValueError, match=msg): - rng2.get_indexer(rng, method="pad") - - def test_dropna_preserve_name(self, datetime_series): - datetime_series[:5] = np.nan - result = datetime_series.dropna() - assert result.name == datetime_series.name - name = datetime_series.name - ts = datetime_series.copy() - return_value = ts.dropna(inplace=True) - assert return_value is None - assert ts.name == name diff --git a/pandas/tests/series/test_period.py b/pandas/tests/series/test_period.py index 2c32342f8802a..c73c57c3d2d91 100644 --- a/pandas/tests/series/test_period.py +++ b/pandas/tests/series/test_period.py @@ -2,35 +2,20 @@ import pytest import pandas as pd -from pandas import DataFrame, Period, Series, period_range +from pandas import DataFrame, Series, period_range import pandas._testing as tm -from pandas.core.arrays import PeriodArray class TestSeriesPeriod: def setup_method(self, method): self.series = Series(period_range("2000-01-01", periods=10, freq="D")) - def test_auto_conversion(self): - series = Series(list(period_range("2000-01-01", periods=10, freq="D"))) - assert series.dtype == "Period[D]" - - series = Series( - [pd.Period("2011-01-01", freq="D"), pd.Period("2011-02-01", freq="D")] - ) - assert series.dtype == "Period[D]" - def test_isna(self): # GH 13737 s = Series([pd.Period("2011-01", freq="M"), pd.Period("NaT", freq="M")]) tm.assert_series_equal(s.isna(), Series([False, True])) tm.assert_series_equal(s.notna(), Series([True, False])) - def test_dropna(self): - # GH 13737 - s = Series([pd.Period("2011-01", freq="M"), pd.Period("NaT", freq="M")]) - tm.assert_series_equal(s.dropna(), Series([pd.Period("2011-01", freq="M")])) - # --------------------------------------------------------------------- # NaT support @@ -61,40 +46,3 @@ def test_intercept_astype_object(self): result = df.values.squeeze() assert (result[:, 0] == expected.values).all() - - @pytest.mark.parametrize( - "input_vals", - [ - [Period("2016-01", freq="M"), Period("2016-02", freq="M")], - [Period("2016-01-01", freq="D"), Period("2016-01-02", freq="D")], - [ - Period("2016-01-01 00:00:00", freq="H"), - Period("2016-01-01 01:00:00", freq="H"), - ], - [ - Period("2016-01-01 00:00:00", freq="M"), - Period("2016-01-01 00:01:00", freq="M"), - ], - [ - Period("2016-01-01 00:00:00", freq="S"), - Period("2016-01-01 00:00:01", freq="S"), - ], - ], - ) - def test_end_time_timevalues(self, input_vals): - # GH 17157 - # Check that the time part of the Period is adjusted by end_time - # when using the dt accessor on a Series - input_vals = PeriodArray._from_sequence(np.asarray(input_vals)) - - s = Series(input_vals) - result = s.dt.end_time - expected = s.apply(lambda x: x.end_time) - tm.assert_series_equal(result, expected) - - @pytest.mark.parametrize("input_vals", [("2001"), ("NaT")]) - def test_to_period(self, input_vals): - # GH 21205 - expected = Series([input_vals], dtype="Period[D]") - result = Series([input_vals], dtype="datetime64[ns]").dt.to_period("D") - tm.assert_series_equal(result, expected) diff --git a/pandas/tests/series/test_timeseries.py b/pandas/tests/series/test_timeseries.py index 31c0e7f54d12b..ba270448c19ed 100644 --- a/pandas/tests/series/test_timeseries.py +++ b/pandas/tests/series/test_timeseries.py @@ -2,19 +2,11 @@ import pytest import pandas as pd -from pandas import DataFrame, DatetimeIndex, Series, date_range, timedelta_range +from pandas import DataFrame, Series, date_range, timedelta_range import pandas._testing as tm class TestTimeSeries: - def test_timeseries_coercion(self): - idx = tm.makeDateIndex(10000) - with tm.assert_produces_warning(FutureWarning): - ser = Series(np.random.randn(len(idx)), idx.astype(object)) - with tm.assert_produces_warning(FutureWarning): - assert ser.index.is_all_dates - assert isinstance(ser.index, DatetimeIndex) - def test_contiguous_boolean_preserve_freq(self): rng = date_range("1/1/2000", "3/1/2000", freq="B") @@ -79,24 +71,6 @@ def f(x): s.apply(f) DataFrame(s).applymap(f) - def test_asfreq_resample_set_correct_freq(self): - # GH5613 - # we test if .asfreq() and .resample() set the correct value for .freq - df = DataFrame( - {"date": ["2012-01-01", "2012-01-02", "2012-01-03"], "col": [1, 2, 3]} - ) - df = df.set_index(pd.to_datetime(df.date)) - - # testing the settings before calling .asfreq() and .resample() - assert df.index.freq is None - assert df.index.inferred_freq == "D" - - # does .asfreq() set .freq correctly? - assert df.asfreq("D").index.freq == "D" - - # does .resample() set .freq correctly? - assert df.resample("D").asfreq().index.freq == "D" - def test_view_tz(self): # GH#24024 ser = Series(pd.date_range("2000", periods=4, tz="US/Central"))