from __future__ import annotations from datetime import ( datetime, timedelta, ) import itertools import numpy as np import pytest from pandas.compat import ( IS64, is_platform_windows, ) import pandas as pd import pandas._testing as tm from pandas.core.api import ( Float64Index, Int64Index, ) ############################################################### # Index / Series common tests which may trigger dtype coercions ############################################################### @pytest.fixture(autouse=True, scope="class") def check_comprehensiveness(request): # Iterate over combination of dtype, method and klass # and ensure that each are contained within a collected test cls = request.cls combos = itertools.product(cls.klasses, cls.dtypes, [cls.method]) def has_test(combo): klass, dtype, method = combo cls_funcs = request.node.session.items return any( klass in x.name and dtype in x.name and method in x.name for x in cls_funcs ) opts = request.config.option if opts.lf or opts.keyword: # If we are running with "last-failed" or -k foo, we expect to only # run a subset of tests. yield else: for combo in combos: if not has_test(combo): raise AssertionError( f"test method is not defined: {cls.__name__}, {combo}" ) yield class CoercionBase: klasses = ["index", "series"] dtypes = [ "object", "int64", "float64", "complex128", "bool", "datetime64", "datetime64tz", "timedelta64", "period", ] @property def method(self): raise NotImplementedError(self) class TestSetitemCoercion(CoercionBase): method = "setitem" # disable comprehensiveness tests, as most of these have been moved to # tests.series.indexing.test_setitem in SetitemCastingEquivalents subclasses. klasses: list[str] = [] def test_setitem_series_no_coercion_from_values_list(self): # GH35865 - int casted to str when internally calling np.array(ser.values) ser = pd.Series(["a", 1]) ser[:] = list(ser.values) expected = pd.Series(["a", 1]) tm.assert_series_equal(ser, expected) def _assert_setitem_index_conversion( self, original_series, loc_key, expected_index, expected_dtype ): """test index's coercion triggered by assign key""" temp = original_series.copy() warn = None if isinstance(loc_key, int) and temp.index.dtype == np.float64: # GH#33469 warn = FutureWarning with tm.assert_produces_warning(warn): temp[loc_key] = 5 exp = pd.Series([1, 2, 3, 4, 5], index=expected_index) tm.assert_series_equal(temp, exp) # check dtype explicitly for sure assert temp.index.dtype == expected_dtype temp = original_series.copy() temp.loc[loc_key] = 5 exp = pd.Series([1, 2, 3, 4, 5], index=expected_index) tm.assert_series_equal(temp, exp) # check dtype explicitly for sure assert temp.index.dtype == expected_dtype @pytest.mark.parametrize( "val,exp_dtype", [("x", object), (5, IndexError), (1.1, object)] ) def test_setitem_index_object(self, val, exp_dtype): obj = pd.Series([1, 2, 3, 4], index=list("abcd")) assert obj.index.dtype == object if exp_dtype is IndexError: temp = obj.copy() msg = "index 5 is out of bounds for axis 0 with size 4" with pytest.raises(exp_dtype, match=msg): temp[5] = 5 else: exp_index = pd.Index(list("abcd") + [val]) self._assert_setitem_index_conversion(obj, val, exp_index, exp_dtype) @pytest.mark.parametrize( "val,exp_dtype", [(5, np.int64), (1.1, np.float64), ("x", object)] ) def test_setitem_index_int64(self, val, exp_dtype): obj = pd.Series([1, 2, 3, 4]) assert obj.index.dtype == np.int64 exp_index = pd.Index([0, 1, 2, 3, val]) self._assert_setitem_index_conversion(obj, val, exp_index, exp_dtype) @pytest.mark.parametrize( "val,exp_dtype", [(5, IndexError), (5.1, np.float64), ("x", object)] ) def test_setitem_index_float64(self, val, exp_dtype, request): obj = pd.Series([1, 2, 3, 4], index=[1.1, 2.1, 3.1, 4.1]) assert obj.index.dtype == np.float64 if exp_dtype is IndexError: # float + int -> int temp = obj.copy() msg = "index 5 is out of bounds for axis 0 with size 4" with pytest.raises(exp_dtype, match=msg): # GH#33469 depr_msg = "Treating integers as positional" with tm.assert_produces_warning(FutureWarning, match=depr_msg): temp[5] = 5 mark = pytest.mark.xfail(reason="TODO_GH12747 The result must be float") request.node.add_marker(mark) exp_index = pd.Index([1.1, 2.1, 3.1, 4.1, val]) self._assert_setitem_index_conversion(obj, val, exp_index, exp_dtype) @pytest.mark.xfail(reason="Test not implemented") def test_setitem_series_period(self): raise NotImplementedError @pytest.mark.xfail(reason="Test not implemented") def test_setitem_index_complex128(self): raise NotImplementedError @pytest.mark.xfail(reason="Test not implemented") def test_setitem_index_bool(self): raise NotImplementedError @pytest.mark.xfail(reason="Test not implemented") def test_setitem_index_datetime64(self): raise NotImplementedError @pytest.mark.xfail(reason="Test not implemented") def test_setitem_index_datetime64tz(self): raise NotImplementedError @pytest.mark.xfail(reason="Test not implemented") def test_setitem_index_timedelta64(self): raise NotImplementedError @pytest.mark.xfail(reason="Test not implemented") def test_setitem_index_period(self): raise NotImplementedError class TestInsertIndexCoercion(CoercionBase): klasses = ["index"] method = "insert" def _assert_insert_conversion(self, original, value, expected, expected_dtype): """test coercion triggered by insert""" target = original.copy() res = target.insert(1, value) tm.assert_index_equal(res, expected) assert res.dtype == expected_dtype @pytest.mark.parametrize( "insert, coerced_val, coerced_dtype", [ (1, 1, object), (1.1, 1.1, object), (False, False, object), ("x", "x", object), ], ) def test_insert_index_object(self, insert, coerced_val, coerced_dtype): obj = pd.Index(list("abcd")) assert obj.dtype == object exp = pd.Index(["a", coerced_val, "b", "c", "d"]) self._assert_insert_conversion(obj, insert, exp, coerced_dtype) @pytest.mark.parametrize( "insert, coerced_val, coerced_dtype", [ (1, 1, np.int64), (1.1, 1.1, np.float64), (False, False, object), # GH#36319 ("x", "x", object), ], ) def test_insert_index_int64(self, insert, coerced_val, coerced_dtype): obj = Int64Index([1, 2, 3, 4]) assert obj.dtype == np.int64 exp = pd.Index([1, coerced_val, 2, 3, 4]) self._assert_insert_conversion(obj, insert, exp, coerced_dtype) @pytest.mark.parametrize( "insert, coerced_val, coerced_dtype", [ (1, 1.0, np.float64), (1.1, 1.1, np.float64), (False, False, object), # GH#36319 ("x", "x", object), ], ) def test_insert_index_float64(self, insert, coerced_val, coerced_dtype): obj = Float64Index([1.0, 2.0, 3.0, 4.0]) assert obj.dtype == np.float64 exp = pd.Index([1.0, coerced_val, 2.0, 3.0, 4.0]) self._assert_insert_conversion(obj, insert, exp, coerced_dtype) @pytest.mark.parametrize( "fill_val,exp_dtype", [ (pd.Timestamp("2012-01-01"), "datetime64[ns]"), (pd.Timestamp("2012-01-01", tz="US/Eastern"), "datetime64[ns, US/Eastern]"), ], ids=["datetime64", "datetime64tz"], ) @pytest.mark.parametrize( "insert_value", [pd.Timestamp("2012-01-01"), pd.Timestamp("2012-01-01", tz="Asia/Tokyo"), 1], ) def test_insert_index_datetimes(self, fill_val, exp_dtype, insert_value): obj = pd.DatetimeIndex( ["2011-01-01", "2011-01-02", "2011-01-03", "2011-01-04"], tz=fill_val.tz ) assert obj.dtype == exp_dtype exp = pd.DatetimeIndex( ["2011-01-01", fill_val.date(), "2011-01-02", "2011-01-03", "2011-01-04"], tz=fill_val.tz, ) self._assert_insert_conversion(obj, fill_val, exp, exp_dtype) if fill_val.tz: # mismatched tzawareness ts = pd.Timestamp("2012-01-01") result = obj.insert(1, ts) expected = obj.astype(object).insert(1, ts) assert expected.dtype == object tm.assert_index_equal(result, expected) # mismatched tz --> cast to object (could reasonably cast to common tz) ts = pd.Timestamp("2012-01-01", tz="Asia/Tokyo") with tm.assert_produces_warning(FutureWarning, match="mismatched timezone"): result = obj.insert(1, ts) # once deprecation is enforced: # expected = obj.insert(1, ts.tz_convert(obj.dtype.tz)) # assert expected.dtype == obj.dtype expected = obj.astype(object).insert(1, ts) tm.assert_index_equal(result, expected) else: # mismatched tzawareness ts = pd.Timestamp("2012-01-01", tz="Asia/Tokyo") result = obj.insert(1, ts) expected = obj.astype(object).insert(1, ts) assert expected.dtype == object tm.assert_index_equal(result, expected) item = 1 result = obj.insert(1, item) expected = obj.astype(object).insert(1, item) assert expected[1] == item assert expected.dtype == object tm.assert_index_equal(result, expected) def test_insert_index_timedelta64(self): obj = pd.TimedeltaIndex(["1 day", "2 day", "3 day", "4 day"]) assert obj.dtype == "timedelta64[ns]" # timedelta64 + timedelta64 => timedelta64 exp = pd.TimedeltaIndex(["1 day", "10 day", "2 day", "3 day", "4 day"]) self._assert_insert_conversion( obj, pd.Timedelta("10 day"), exp, "timedelta64[ns]" ) for item in [pd.Timestamp("2012-01-01"), 1]: result = obj.insert(1, item) expected = obj.astype(object).insert(1, item) assert expected.dtype == object tm.assert_index_equal(result, expected) @pytest.mark.parametrize( "insert, coerced_val, coerced_dtype", [ (pd.Period("2012-01", freq="M"), "2012-01", "period[M]"), (pd.Timestamp("2012-01-01"), pd.Timestamp("2012-01-01"), object), (1, 1, object), ("x", "x", object), ], ) def test_insert_index_period(self, insert, coerced_val, coerced_dtype): obj = pd.PeriodIndex(["2011-01", "2011-02", "2011-03", "2011-04"], freq="M") assert obj.dtype == "period[M]" data = [ pd.Period("2011-01", freq="M"), coerced_val, pd.Period("2011-02", freq="M"), pd.Period("2011-03", freq="M"), pd.Period("2011-04", freq="M"), ] if isinstance(insert, pd.Period): exp = pd.PeriodIndex(data, freq="M") self._assert_insert_conversion(obj, insert, exp, coerced_dtype) # string that can be parsed to appropriate PeriodDtype self._assert_insert_conversion(obj, str(insert), exp, coerced_dtype) else: result = obj.insert(0, insert) expected = obj.astype(object).insert(0, insert) tm.assert_index_equal(result, expected) # TODO: ATM inserting '2012-01-01 00:00:00' when we have obj.freq=="M" # casts that string to Period[M], not clear that is desirable if not isinstance(insert, pd.Timestamp): # non-castable string result = obj.insert(0, str(insert)) expected = obj.astype(object).insert(0, str(insert)) tm.assert_index_equal(result, expected) msg = r"Unexpected keyword arguments {'freq'}" with pytest.raises(TypeError, match=msg): with tm.assert_produces_warning(FutureWarning): # passing keywords to pd.Index pd.Index(data, freq="M") @pytest.mark.xfail(reason="Test not implemented") def test_insert_index_complex128(self): raise NotImplementedError @pytest.mark.xfail(reason="Test not implemented") def test_insert_index_bool(self): raise NotImplementedError class TestWhereCoercion(CoercionBase): method = "where" _cond = np.array([True, False, True, False]) def _assert_where_conversion( self, original, cond, values, expected, expected_dtype ): """test coercion triggered by where""" target = original.copy() res = target.where(cond, values) tm.assert_equal(res, expected) assert res.dtype == expected_dtype def _construct_exp(self, obj, klass, fill_val, exp_dtype): if fill_val is True: values = klass([True, False, True, True]) elif isinstance(fill_val, (datetime, np.datetime64)): values = pd.date_range(fill_val, periods=4) else: values = klass(x * fill_val for x in [5, 6, 7, 8]) exp = klass([obj[0], values[1], obj[2], values[3]], dtype=exp_dtype) return values, exp def _run_test(self, obj, fill_val, klass, exp_dtype): cond = klass(self._cond) exp = klass([obj[0], fill_val, obj[2], fill_val], dtype=exp_dtype) self._assert_where_conversion(obj, cond, fill_val, exp, exp_dtype) values, exp = self._construct_exp(obj, klass, fill_val, exp_dtype) self._assert_where_conversion(obj, cond, values, exp, exp_dtype) @pytest.mark.parametrize( "fill_val,exp_dtype", [(1, object), (1.1, object), (1 + 1j, object), (True, object)], ) def test_where_object(self, index_or_series, fill_val, exp_dtype): klass = index_or_series obj = klass(list("abcd")) assert obj.dtype == object self._run_test(obj, fill_val, klass, exp_dtype) @pytest.mark.parametrize( "fill_val,exp_dtype", [(1, np.int64), (1.1, np.float64), (1 + 1j, np.complex128), (True, object)], ) def test_where_int64(self, index_or_series, fill_val, exp_dtype, request): klass = index_or_series obj = klass([1, 2, 3, 4]) assert obj.dtype == np.int64 self._run_test(obj, fill_val, klass, exp_dtype) @pytest.mark.parametrize( "fill_val, exp_dtype", [(1, np.float64), (1.1, np.float64), (1 + 1j, np.complex128), (True, object)], ) def test_where_float64(self, index_or_series, fill_val, exp_dtype, request): klass = index_or_series obj = klass([1.1, 2.2, 3.3, 4.4]) assert obj.dtype == np.float64 self._run_test(obj, fill_val, klass, exp_dtype) @pytest.mark.parametrize( "fill_val,exp_dtype", [ (1, np.complex128), (1.1, np.complex128), (1 + 1j, np.complex128), (True, object), ], ) def test_where_complex128(self, index_or_series, fill_val, exp_dtype): klass = index_or_series obj = klass([1 + 1j, 2 + 2j, 3 + 3j, 4 + 4j], dtype=np.complex128) assert obj.dtype == np.complex128 self._run_test(obj, fill_val, klass, exp_dtype) @pytest.mark.parametrize( "fill_val,exp_dtype", [(1, object), (1.1, object), (1 + 1j, object), (True, np.bool_)], ) def test_where_series_bool(self, fill_val, exp_dtype): klass = pd.Series # TODO: use index_or_series once we have Index[bool] obj = klass([True, False, True, False]) assert obj.dtype == np.bool_ self._run_test(obj, fill_val, klass, exp_dtype) @pytest.mark.parametrize( "fill_val,exp_dtype", [ (pd.Timestamp("2012-01-01"), "datetime64[ns]"), (pd.Timestamp("2012-01-01", tz="US/Eastern"), object), ], ids=["datetime64", "datetime64tz"], ) def test_where_datetime64(self, index_or_series, fill_val, exp_dtype): klass = index_or_series obj = klass(pd.date_range("2011-01-01", periods=4, freq="D")._with_freq(None)) assert obj.dtype == "datetime64[ns]" fv = fill_val # do the check with each of the available datetime scalars if exp_dtype == "datetime64[ns]": for scalar in [fv, fv.to_pydatetime(), fv.to_datetime64()]: self._run_test(obj, scalar, klass, exp_dtype) else: for scalar in [fv, fv.to_pydatetime()]: self._run_test(obj, fill_val, klass, exp_dtype) @pytest.mark.xfail(reason="Test not implemented") def test_where_index_complex128(self): raise NotImplementedError @pytest.mark.xfail(reason="Test not implemented") def test_where_index_bool(self): raise NotImplementedError @pytest.mark.xfail(reason="Test not implemented") def test_where_series_timedelta64(self): raise NotImplementedError @pytest.mark.xfail(reason="Test not implemented") def test_where_series_period(self): raise NotImplementedError @pytest.mark.parametrize( "value", [pd.Timedelta(days=9), timedelta(days=9), np.timedelta64(9, "D")] ) def test_where_index_timedelta64(self, value): tdi = pd.timedelta_range("1 Day", periods=4) cond = np.array([True, False, False, True]) expected = pd.TimedeltaIndex(["1 Day", value, value, "4 Days"]) result = tdi.where(cond, value) tm.assert_index_equal(result, expected) # wrong-dtyped NaT dtnat = np.datetime64("NaT", "ns") expected = pd.Index([tdi[0], dtnat, dtnat, tdi[3]], dtype=object) assert expected[1] is dtnat result = tdi.where(cond, dtnat) tm.assert_index_equal(result, expected) def test_where_index_period(self): dti = pd.date_range("2016-01-01", periods=3, freq="QS") pi = dti.to_period("Q") cond = np.array([False, True, False]) # Passing a valid scalar value = pi[-1] + pi.freq * 10 expected = pd.PeriodIndex([value, pi[1], value]) result = pi.where(cond, value) tm.assert_index_equal(result, expected) # Case passing ndarray[object] of Periods other = np.asarray(pi + pi.freq * 10, dtype=object) result = pi.where(cond, other) expected = pd.PeriodIndex([other[0], pi[1], other[2]]) tm.assert_index_equal(result, expected) # Passing a mismatched scalar -> casts to object td = pd.Timedelta(days=4) expected = pd.Index([td, pi[1], td], dtype=object) result = pi.where(cond, td) tm.assert_index_equal(result, expected) per = pd.Period("2020-04-21", "D") expected = pd.Index([per, pi[1], per], dtype=object) result = pi.where(cond, per) tm.assert_index_equal(result, expected) class TestFillnaSeriesCoercion(CoercionBase): # not indexing, but place here for consistency method = "fillna" @pytest.mark.xfail(reason="Test not implemented") def test_has_comprehensive_tests(self): raise NotImplementedError def _assert_fillna_conversion(self, original, value, expected, expected_dtype): """test coercion triggered by fillna""" target = original.copy() res = target.fillna(value) tm.assert_equal(res, expected) assert res.dtype == expected_dtype @pytest.mark.parametrize( "fill_val, fill_dtype", [(1, object), (1.1, object), (1 + 1j, object), (True, object)], ) def test_fillna_object(self, index_or_series, fill_val, fill_dtype): klass = index_or_series obj = klass(["a", np.nan, "c", "d"]) assert obj.dtype == object exp = klass(["a", fill_val, "c", "d"]) self._assert_fillna_conversion(obj, fill_val, exp, fill_dtype) @pytest.mark.parametrize( "fill_val,fill_dtype", [(1, np.float64), (1.1, np.float64), (1 + 1j, np.complex128), (True, object)], ) def test_fillna_float64(self, index_or_series, fill_val, fill_dtype): klass = index_or_series obj = klass([1.1, np.nan, 3.3, 4.4]) assert obj.dtype == np.float64 exp = klass([1.1, fill_val, 3.3, 4.4]) self._assert_fillna_conversion(obj, fill_val, exp, fill_dtype) @pytest.mark.parametrize( "fill_val,fill_dtype", [ (1, np.complex128), (1.1, np.complex128), (1 + 1j, np.complex128), (True, object), ], ) def test_fillna_complex128(self, index_or_series, fill_val, fill_dtype): klass = index_or_series obj = klass([1 + 1j, np.nan, 3 + 3j, 4 + 4j], dtype=np.complex128) assert obj.dtype == np.complex128 exp = klass([1 + 1j, fill_val, 3 + 3j, 4 + 4j]) self._assert_fillna_conversion(obj, fill_val, exp, fill_dtype) @pytest.mark.parametrize( "fill_val,fill_dtype", [ (pd.Timestamp("2012-01-01"), "datetime64[ns]"), (pd.Timestamp("2012-01-01", tz="US/Eastern"), object), (1, object), ("x", object), ], ids=["datetime64", "datetime64tz", "object", "object"], ) def test_fillna_datetime(self, index_or_series, fill_val, fill_dtype): klass = index_or_series obj = klass( [ pd.Timestamp("2011-01-01"), pd.NaT, pd.Timestamp("2011-01-03"), pd.Timestamp("2011-01-04"), ] ) assert obj.dtype == "datetime64[ns]" exp = klass( [ pd.Timestamp("2011-01-01"), fill_val, pd.Timestamp("2011-01-03"), pd.Timestamp("2011-01-04"), ] ) self._assert_fillna_conversion(obj, fill_val, exp, fill_dtype) @pytest.mark.parametrize( "fill_val,fill_dtype", [ (pd.Timestamp("2012-01-01", tz="US/Eastern"), "datetime64[ns, US/Eastern]"), (pd.Timestamp("2012-01-01"), object), (pd.Timestamp("2012-01-01", tz="Asia/Tokyo"), object), (1, object), ("x", object), ], ) def test_fillna_datetime64tz(self, index_or_series, fill_val, fill_dtype): klass = index_or_series tz = "US/Eastern" obj = klass( [ pd.Timestamp("2011-01-01", tz=tz), pd.NaT, pd.Timestamp("2011-01-03", tz=tz), pd.Timestamp("2011-01-04", tz=tz), ] ) assert obj.dtype == "datetime64[ns, US/Eastern]" exp = klass( [ pd.Timestamp("2011-01-01", tz=tz), fill_val, # Once deprecation is enforced, this becomes: # fill_val.tz_convert(tz) if getattr(fill_val, "tz", None) # is not None else fill_val, pd.Timestamp("2011-01-03", tz=tz), pd.Timestamp("2011-01-04", tz=tz), ] ) warn = None if getattr(fill_val, "tz", None) is not None and fill_val.tz != obj[0].tz: warn = FutureWarning with tm.assert_produces_warning(warn, match="mismatched timezone"): self._assert_fillna_conversion(obj, fill_val, exp, fill_dtype) @pytest.mark.parametrize( "fill_val", [ 1, 1.1, 1 + 1j, True, pd.Interval(1, 2, closed="left"), pd.Timestamp("2012-01-01", tz="US/Eastern"), pd.Timestamp("2012-01-01"), pd.Timedelta(days=1), pd.Period("2016-01-01", "D"), ], ) def test_fillna_interval(self, index_or_series, fill_val): ii = pd.interval_range(1.0, 5.0, closed="right").insert(1, np.nan) assert isinstance(ii.dtype, pd.IntervalDtype) obj = index_or_series(ii) exp = index_or_series([ii[0], fill_val, ii[2], ii[3], ii[4]], dtype=object) fill_dtype = object self._assert_fillna_conversion(obj, fill_val, exp, fill_dtype) @pytest.mark.xfail(reason="Test not implemented") def test_fillna_series_int64(self): raise NotImplementedError @pytest.mark.xfail(reason="Test not implemented") def test_fillna_index_int64(self): raise NotImplementedError @pytest.mark.xfail(reason="Test not implemented") def test_fillna_series_bool(self): raise NotImplementedError @pytest.mark.xfail(reason="Test not implemented") def test_fillna_index_bool(self): raise NotImplementedError @pytest.mark.xfail(reason="Test not implemented") def test_fillna_series_timedelta64(self): raise NotImplementedError @pytest.mark.parametrize( "fill_val", [ 1, 1.1, 1 + 1j, True, pd.Interval(1, 2, closed="left"), pd.Timestamp("2012-01-01", tz="US/Eastern"), pd.Timestamp("2012-01-01"), pd.Timedelta(days=1), pd.Period("2016-01-01", "W"), ], ) def test_fillna_series_period(self, index_or_series, fill_val): pi = pd.period_range("2016-01-01", periods=4, freq="D").insert(1, pd.NaT) assert isinstance(pi.dtype, pd.PeriodDtype) obj = index_or_series(pi) exp = index_or_series([pi[0], fill_val, pi[2], pi[3], pi[4]], dtype=object) fill_dtype = object self._assert_fillna_conversion(obj, fill_val, exp, fill_dtype) @pytest.mark.xfail(reason="Test not implemented") def test_fillna_index_timedelta64(self): raise NotImplementedError @pytest.mark.xfail(reason="Test not implemented") def test_fillna_index_period(self): raise NotImplementedError class TestReplaceSeriesCoercion(CoercionBase): klasses = ["series"] method = "replace" rep: dict[str, list] = {} rep["object"] = ["a", "b"] rep["int64"] = [4, 5] rep["float64"] = [1.1, 2.2] rep["complex128"] = [1 + 1j, 2 + 2j] rep["bool"] = [True, False] rep["datetime64[ns]"] = [pd.Timestamp("2011-01-01"), pd.Timestamp("2011-01-03")] for tz in ["UTC", "US/Eastern"]: # to test tz => different tz replacement key = f"datetime64[ns, {tz}]" rep[key] = [ pd.Timestamp("2011-01-01", tz=tz), pd.Timestamp("2011-01-03", tz=tz), ] rep["timedelta64[ns]"] = [pd.Timedelta("1 day"), pd.Timedelta("2 day")] @pytest.fixture(params=["dict", "series"]) def how(self, request): return request.param @pytest.fixture( params=[ "object", "int64", "float64", "complex128", "bool", "datetime64[ns]", "datetime64[ns, UTC]", "datetime64[ns, US/Eastern]", "timedelta64[ns]", ] ) def from_key(self, request): return request.param @pytest.fixture( params=[ "object", "int64", "float64", "complex128", "bool", "datetime64[ns]", "datetime64[ns, UTC]", "datetime64[ns, US/Eastern]", "timedelta64[ns]", ], ids=[ "object", "int64", "float64", "complex128", "bool", "datetime64", "datetime64tz", "datetime64tz", "timedelta64", ], ) def to_key(self, request): return request.param @pytest.fixture def replacer(self, how, from_key, to_key): """ Object we will pass to `Series.replace` """ if how == "dict": replacer = dict(zip(self.rep[from_key], self.rep[to_key])) elif how == "series": replacer = pd.Series(self.rep[to_key], index=self.rep[from_key]) else: raise ValueError return replacer def test_replace_series(self, how, to_key, from_key, replacer): index = pd.Index([3, 4], name="xxx") obj = pd.Series(self.rep[from_key], index=index, name="yyy") assert obj.dtype == from_key if from_key.startswith("datetime") and to_key.startswith("datetime"): # tested below return elif from_key in ["datetime64[ns, US/Eastern]", "datetime64[ns, UTC]"]: # tested below return result = obj.replace(replacer) if (from_key == "float64" and to_key in ("int64")) or ( from_key == "complex128" and to_key in ("int64", "float64") ): if not IS64 or is_platform_windows(): pytest.skip(f"32-bit platform buggy: {from_key} -> {to_key}") # Expected: do not downcast by replacement exp = pd.Series(self.rep[to_key], index=index, name="yyy", dtype=from_key) else: exp = pd.Series(self.rep[to_key], index=index, name="yyy") assert exp.dtype == to_key tm.assert_series_equal(result, exp) @pytest.mark.parametrize( "to_key", ["timedelta64[ns]", "bool", "object", "complex128", "float64", "int64"], indirect=True, ) @pytest.mark.parametrize( "from_key", ["datetime64[ns, UTC]", "datetime64[ns, US/Eastern]"], indirect=True ) def test_replace_series_datetime_tz(self, how, to_key, from_key, replacer): index = pd.Index([3, 4], name="xyz") obj = pd.Series(self.rep[from_key], index=index, name="yyy") assert obj.dtype == from_key result = obj.replace(replacer) exp = pd.Series(self.rep[to_key], index=index, name="yyy") assert exp.dtype == to_key tm.assert_series_equal(result, exp) @pytest.mark.parametrize( "to_key", ["datetime64[ns]", "datetime64[ns, UTC]", "datetime64[ns, US/Eastern]"], indirect=True, ) @pytest.mark.parametrize( "from_key", ["datetime64[ns]", "datetime64[ns, UTC]", "datetime64[ns, US/Eastern]"], indirect=True, ) def test_replace_series_datetime_datetime(self, how, to_key, from_key, replacer): index = pd.Index([3, 4], name="xyz") obj = pd.Series(self.rep[from_key], index=index, name="yyy") assert obj.dtype == from_key warn = None rep_ser = pd.Series(replacer) if ( isinstance(obj.dtype, pd.DatetimeTZDtype) and isinstance(rep_ser.dtype, pd.DatetimeTZDtype) and obj.dtype != rep_ser.dtype ): # mismatched tz DatetimeArray behavior will change to cast # for setitem-like methods with mismatched tzs GH#44940 warn = FutureWarning msg = "explicitly cast to object" with tm.assert_produces_warning(warn, match=msg): result = obj.replace(replacer) exp = pd.Series(self.rep[to_key], index=index, name="yyy") assert exp.dtype == to_key tm.assert_series_equal(result, exp) @pytest.mark.xfail(reason="Test not implemented") def test_replace_series_period(self): raise NotImplementedError