def test_astype_copy(): arr = pd.array([0.1, 0.2, None], dtype="Float64") orig = pd.array([0.1, 0.2, None], dtype="Float64") # copy=True -> ensure both data and mask are actual copies result = arr.astype("Float64", copy=True) assert result is not arr assert not tm.shares_memory(result, arr) result[0] = 10 tm.assert_extension_array_equal(arr, orig) result[0] = pd.NA tm.assert_extension_array_equal(arr, orig) # copy=False result = arr.astype("Float64", copy=False) assert result is arr assert np.shares_memory(result._data, arr._data) assert np.shares_memory(result._mask, arr._mask) result[0] = 10 assert arr[0] == 10 result[0] = pd.NA assert arr[0] is pd.NA # astype to different dtype -> always needs a copy -> even with copy=False # we need to ensure that also the mask is actually copied arr = pd.array([0.1, 0.2, None], dtype="Float64") orig = pd.array([0.1, 0.2, None], dtype="Float64") result = arr.astype("Float32", copy=False) assert not tm.shares_memory(result, arr) result[0] = 10 tm.assert_extension_array_equal(arr, orig) result[0] = pd.NA tm.assert_extension_array_equal(arr, orig)
def test_shares_memory_interval(): obj = pd.interval_range(1, 5) assert tm.shares_memory(obj, obj) assert tm.shares_memory(obj, obj._data) assert tm.shares_memory(obj, obj[::-1]) assert tm.shares_memory(obj, obj[:2]) assert not tm.shares_memory(obj, obj._data.copy())
def test_tz_localize_utc_copies(self, utc_fixture): # GH#46460 times = ["2015-03-08 01:00", "2015-03-08 02:00", "2015-03-08 03:00"] index = DatetimeIndex(times) res = index.tz_localize(utc_fixture) assert not tm.shares_memory(res, index) res2 = index._data.tz_localize(utc_fixture) assert not tm.shares_memory(index._data, res2)
def test_pos(self): vals = np.array([-3600 * 10**9, "NaT", 7200 * 10**9], dtype="m8[ns]") arr = TimedeltaArray(vals) result = +arr tm.assert_timedelta_array_equal(result, arr) assert not tm.shares_memory(result, arr) result2 = np.positive(arr) tm.assert_timedelta_array_equal(result2, arr) assert not tm.shares_memory(result2, arr)
def test_array_copy(): a = np.array([1, 2]) # default is to copy b = pd.array(a, dtype=a.dtype) assert not tm.shares_memory(a, b) # copy=True b = pd.array(a, dtype=a.dtype, copy=True) assert not tm.shares_memory(a, b) # copy=False b = pd.array(a, dtype=a.dtype, copy=False) assert tm.shares_memory(a, b)
def test_iloc_setitem_categorical_updates_inplace(self): # Mixed dtype ensures we go through take_split_path in setitem_with_indexer cat = Categorical(["A", "B", "C"]) df = DataFrame({1: cat, 2: [1, 2, 3]}, copy=False) assert tm.shares_memory(df[1], cat) # This should modify our original values in-place df.iloc[:, 0] = cat[::-1] assert tm.shares_memory(df[1], cat) expected = Categorical(["C", "B", "A"], categories=["A", "B", "C"]) tm.assert_categorical_equal(cat, expected)
def test_ensure_copied_data(self, index): # Check the "copy" argument of each Index.__new__ is honoured # GH12309 init_kwargs = {} if isinstance(index, PeriodIndex): # Needs "freq" specification: init_kwargs["freq"] = index.freq elif isinstance(index, (RangeIndex, MultiIndex, CategoricalIndex)): # RangeIndex cannot be initialized from data # MultiIndex and CategoricalIndex are tested separately return index_type = type(index) result = index_type(index.values, copy=True, **init_kwargs) if is_datetime64tz_dtype(index.dtype): result = result.tz_localize("UTC").tz_convert(index.tz) if isinstance(index, (DatetimeIndex, TimedeltaIndex)): index = index._with_freq(None) tm.assert_index_equal(index, result) if isinstance(index, PeriodIndex): # .values an object array of Period, thus copied result = index_type(ordinal=index.asi8, copy=False, **init_kwargs) tm.assert_numpy_array_equal(index.asi8, result.asi8, check_same="same") elif isinstance(index, IntervalIndex): # checked in test_interval.py pass elif type(index) is Index and not isinstance(index.dtype, np.dtype): result = index_type(index.values, copy=False, **init_kwargs) tm.assert_index_equal(result, index) if isinstance(index._values, BaseMaskedArray): assert np.shares_memory(index._values._data, result._values._data) tm.assert_numpy_array_equal(index._values._data, result._values._data, check_same="same") assert np.shares_memory(index._values._mask, result._values._mask) tm.assert_numpy_array_equal(index._values._mask, result._values._mask, check_same="same") elif index.dtype == "string[python]": assert np.shares_memory(index._values._ndarray, result._values._ndarray) tm.assert_numpy_array_equal(index._values._ndarray, result._values._ndarray, check_same="same") elif index.dtype == "string[pyarrow]": assert tm.shares_memory(result._values, index._values) else: raise NotImplementedError(index.dtype) else: result = index_type(index.values, copy=False, **init_kwargs) tm.assert_numpy_array_equal(index.values, result.values, check_same="same")
def test_astype_non_nano_tzaware(self): dti = pd.date_range("2016-01-01", periods=3, tz="UTC") res = dti.astype("M8[s, US/Pacific]") assert res.dtype == "M8[s, US/Pacific]" dta = dti._data res = dta.astype("M8[s, US/Pacific]") assert res.dtype == "M8[s, US/Pacific]" # from non-nano to non-nano, preserving reso res2 = res.astype("M8[s, UTC]") assert res2.dtype == "M8[s, UTC]" assert not tm.shares_memory(res2, res) res3 = res.astype("M8[s, UTC]", copy=False) assert res2.dtype == "M8[s, UTC]" assert tm.shares_memory(res3, res)
def test_from_sequence_copy(self): cat = Categorical(np.arange(5).repeat(2)) result = Categorical._from_sequence(cat, dtype=None, copy=False) # more generally, we'd be OK with a view assert result._codes is cat._codes result = Categorical._from_sequence(cat, dtype=None, copy=True) assert not tm.shares_memory(result, cat)
def test_unary_int_operators(any_signed_int_ea_dtype, source, neg_target, abs_target): dtype = any_signed_int_ea_dtype arr = pd.array(source, dtype=dtype) neg_result, pos_result, abs_result = -arr, +arr, abs(arr) neg_target = pd.array(neg_target, dtype=dtype) abs_target = pd.array(abs_target, dtype=dtype) tm.assert_extension_array_equal(neg_result, neg_target) tm.assert_extension_array_equal(pos_result, arr) assert not tm.shares_memory(pos_result, arr) tm.assert_extension_array_equal(abs_result, abs_target)
def test_no_shared_mask(self, data): result = data + 1 assert not tm.shares_memory(result, data)
def test_constructor_copy(): arr = np.array([0, 1]) result = PandasArray(arr, copy=True) assert not tm.shares_memory(result, arr)