API: Copy inputs in Index subclass constructors by default (GH#63388)

doc/source/whatsnew/v3.0.0.rst

@@ -820,6 +820,7 @@ Other API changes
   :meth:`~DataFrame.ffill`, :meth:`~DataFrame.bfill`, :meth:`~DataFrame.interpolate`,
   :meth:`~DataFrame.where`, :meth:`~DataFrame.mask`, :meth:`~DataFrame.clip`) now return
   the modified DataFrame or Series (``self``) instead of ``None`` when ``inplace=True`` (:issue:`63207`)
+- :class:`DatetimeIndex`, :class:`TimedeltaIndex`, :class:`PeriodIndex` and :class:`IntervalIndex` constructors now copy the input ``data`` by default when ``copy=None``, consistent with :class:`Index` behavior (:issue:`63388`)
 
 .. ---------------------------------------------------------------------------
 .. _whatsnew_300.deprecations:

pandas/core/indexes/datetimes.py

@@ -37,14 +37,19 @@
 )
 from pandas.util._exceptions import find_stack_level
 
-from pandas.core.dtypes.common import is_scalar
+from pandas.core.dtypes.astype import astype_is_view
+from pandas.core.dtypes.common import (
+    is_scalar,
+    pandas_dtype,
+)
 from pandas.core.dtypes.dtypes import (
     ArrowDtype,
     DatetimeTZDtype,
 )
 from pandas.core.dtypes.generic import ABCSeries
 from pandas.core.dtypes.missing import is_valid_na_for_dtype
 
+from pandas.core.arrays import ExtensionArray
 from pandas.core.arrays.datetimes import (
     DatetimeArray,
     tz_to_dtype,
@@ -181,8 +186,13 @@ class DatetimeIndex(DatetimeTimedeltaMixin):
         If True parse dates in `data` with the year first order.
     dtype : numpy.dtype or DatetimeTZDtype or str, default None
         Note that the only NumPy dtype allowed is `datetime64[ns]`.
-    copy : bool, default False
-        Make a copy of input ndarray.
+    copy : bool, default None
+        Whether to copy input data, only relevant for array, Series, and Index
+        inputs (for other input, e.g. a list, a new array is created anyway).
+        Defaults to True for array input and False for Index/Series.
+        Set to False to avoid copying array input at your own risk (if you
+        know the input data won't be modified elsewhere).
+        Set to True to force copying Series/Index up front.
     name : label, default None
         Name to be stored in the index.
 
@@ -669,7 +679,7 @@ def __new__(
         dayfirst: bool = False,
         yearfirst: bool = False,
         dtype: Dtype | None = None,
-        copy: bool = False,
+        copy: bool | None = None,
         name: Hashable | None = None,
     ) -> Self:
         if is_scalar(data):
@@ -679,6 +689,16 @@ def __new__(
 
         name = maybe_extract_name(name, data, cls)
 
+        if isinstance(data, (ExtensionArray, np.ndarray)):
+            # GH 63388
+            if copy is not False:
+                if dtype is None or astype_is_view(
+                    data.dtype,
+                    pandas_dtype(dtype),
+                ):
+                    data = data.copy()
+                    copy = False
+
         if (
             isinstance(data, DatetimeArray)
             and freq is lib.no_default
@@ -694,7 +714,7 @@ def __new__(
         dtarr = DatetimeArray._from_sequence_not_strict(
             data,
             dtype=dtype,
-            copy=copy,
+            copy=bool(copy),
             tz=tz,
             freq=freq,
             dayfirst=dayfirst,

pandas/core/indexes/interval.py

@@ -35,6 +35,7 @@
 )
 from pandas.util._exceptions import rewrite_exception
 
+from pandas.core.dtypes.astype import astype_is_view
 from pandas.core.dtypes.cast import (
     find_common_type,
     infer_dtype_from_scalar,
@@ -61,6 +62,7 @@
 from pandas.core.dtypes.missing import is_valid_na_for_dtype
 
 from pandas.core.algorithms import unique
+from pandas.core.arrays import ExtensionArray
 from pandas.core.arrays.datetimelike import validate_periods
 from pandas.core.arrays.interval import (
     IntervalArray,
@@ -169,8 +171,13 @@ class IntervalIndex(ExtensionIndex):
         neither.
     dtype : dtype or None, default None
         If None, dtype will be inferred.
-    copy : bool, default False
-        Copy the input data.
+    copy : bool, default None
+        Whether to copy input data, only relevant for array, Series, and Index
+        inputs (for other input, e.g. a list, a new array is created anyway).
+        Defaults to True for array input and False for Index/Series.
+        Set to False to avoid copying array input at your own risk (if you
+        know the input data won't be modified elsewhere).
+        Set to True to force copying Series/Index input up front.
     name : object, optional
          Name to be stored in the index.
     verify_integrity : bool, default True
@@ -252,17 +259,27 @@ def __new__(
         data,
         closed: IntervalClosedType | None = None,
         dtype: Dtype | None = None,
-        copy: bool = False,
+        copy: bool | None = None,
         name: Hashable | None = None,
         verify_integrity: bool = True,
     ) -> Self:
         name = maybe_extract_name(name, data, cls)
 
+        if isinstance(data, (ExtensionArray, np.ndarray)):
+            # GH#63388
+            if copy is not False:
+                if dtype is None or astype_is_view(
+                    data.dtype,
+                    pandas_dtype(dtype),
+                ):
+                    data = data.copy()
+                    copy = False
+
         with rewrite_exception("IntervalArray", cls.__name__):
             array = IntervalArray(
                 data,
                 closed=closed,
-                copy=copy,
+                copy=bool(copy),
                 dtype=dtype,
                 verify_integrity=verify_integrity,
             )

pandas/core/indexes/period.py

@@ -27,11 +27,16 @@
     set_module,
 )
 
-from pandas.core.dtypes.common import is_integer
+from pandas.core.dtypes.astype import astype_is_view
+from pandas.core.dtypes.common import (
+    is_integer,
+    pandas_dtype,
+)
 from pandas.core.dtypes.dtypes import PeriodDtype
 from pandas.core.dtypes.generic import ABCSeries
 from pandas.core.dtypes.missing import is_valid_na_for_dtype
 
+from pandas.core.arrays import ExtensionArray
 from pandas.core.arrays.period import (
     PeriodArray,
     period_array,
@@ -101,8 +106,13 @@ class PeriodIndex(DatetimeIndexOpsMixin):
         One of pandas period strings or corresponding objects.
     dtype : str or PeriodDtype, default None
         A dtype from which to extract a freq.
-    copy : bool
-        Make a copy of input ndarray.
+    copy : bool, default None
+        Whether to copy input data, only relevant for array, Series, and Index
+        inputs (for other input, e.g. a list, a new array is created anyway).
+        Defaults to True for array input and False for Index/Series.
+        Set to False to avoid copying array input at your own risk (if you
+        know the input data won't be modified elsewhere).
+        Set to True to force copying Series/Index input up front.
     name : str, default None
         Name of the resulting PeriodIndex.
 
@@ -220,7 +230,7 @@ def __new__(
         data=None,
         freq=None,
         dtype: Dtype | None = None,
-        copy: bool = False,
+        copy: bool | None = None,
         name: Hashable | None = None,
     ) -> Self:
         refs = None
@@ -231,6 +241,16 @@ def __new__(
 
         freq = validate_dtype_freq(dtype, freq)
 
+        if isinstance(data, (ExtensionArray, np.ndarray)):
+            # GH 63388
+            if copy is not False:
+                if dtype is None or astype_is_view(
+                    data.dtype,
+                    pandas_dtype(dtype),
+                ):
+                    data = data.copy()
+                    copy = False
+
         # PeriodIndex allow PeriodIndex(period_index, freq=different)
         # Let's not encourage that kind of behavior in PeriodArray.
 

pandas/core/indexes/timedeltas.py

@@ -7,6 +7,8 @@
     cast,
 )
 
+import numpy as np
+
 from pandas._libs import (
     index as libindex,
     lib,
@@ -19,13 +21,15 @@
 from pandas._libs.tslibs.dtypes import abbrev_to_npy_unit
 from pandas.util._decorators import set_module
 
+from pandas.core.dtypes.astype import astype_is_view
 from pandas.core.dtypes.common import (
     is_scalar,
     pandas_dtype,
 )
 from pandas.core.dtypes.dtypes import ArrowDtype
 from pandas.core.dtypes.generic import ABCSeries
 
+from pandas.core.arrays import ExtensionArray
 from pandas.core.arrays.timedeltas import TimedeltaArray
 import pandas.core.common as com
 from pandas.core.indexes.base import (
@@ -81,8 +85,13 @@ class TimedeltaIndex(DatetimeTimedeltaMixin):
     dtype : numpy.dtype or str, default None
         Valid ``numpy`` dtypes are ``timedelta64[ns]``, ``timedelta64[us]``,
         ``timedelta64[ms]``, and ``timedelta64[s]``.
-    copy : bool
-        Make a copy of input array.
+    copy : bool, default None
+        Whether to copy input data, only relevant for array, Series, and Index
+        inputs (for other input, e.g. a list, a new array is created anyway).
+        Defaults to True for array input and False for Index/Series.
+        Set to False to avoid copying array input at your own risk (if you
+        know the input data won't be modified elsewhere).
+        Set to True to force copying Series/Index input up front.
     name : object
         Name to be stored in the index.
 
@@ -158,11 +167,21 @@ def __new__(
         data=None,
         freq=lib.no_default,
         dtype=None,
-        copy: bool = False,
+        copy: bool | None = None,
         name=None,
     ):
         name = maybe_extract_name(name, data, cls)
 
+        if isinstance(data, (ExtensionArray, np.ndarray)):
+            # GH 63388
+            if copy is not False:
+                if dtype is None or astype_is_view(
+                    data.dtype,
+                    pandas_dtype(dtype),
+                ):
+                    data = data.copy()
+                    copy = False
+
         if is_scalar(data):
             cls._raise_scalar_data_error(data)
 
@@ -192,7 +211,7 @@ def __new__(
         # - Cases checked above all return/raise before reaching here - #
 
         tdarr = TimedeltaArray._from_sequence_not_strict(
-            data, freq=freq, unit=None, dtype=dtype, copy=copy
+            data, freq=freq, unit=None, dtype=dtype, copy=bool(copy)
         )
         refs = None
         if not copy and isinstance(data, (ABCSeries, Index)):

pandas/tests/arrays/test_datetimelike.py

@@ -707,7 +707,7 @@ def test_array_object_dtype(self, arr1d):
     def test_array_tz(self, arr1d):
         # GH#23524
         arr = arr1d
-        dti = self.index_cls(arr1d)
+        dti = self.index_cls(arr1d, copy=False)
         copy_false = None if np_version_gt2 else False
 
         expected = dti.asi8.view("M8[ns]")

pandas/tests/copy_view/index/test_datetimeindex.py

@@ -1,12 +1,15 @@
+import numpy as np
 import pytest
 
 from pandas import (
     DatetimeIndex,
     Series,
     Timestamp,
+    array,
     date_range,
 )
 import pandas._testing as tm
+from pandas.tests.copy_view.util import get_array
 
 pytestmark = pytest.mark.filterwarnings(
     "ignore:Setting a value on a view:FutureWarning"
@@ -54,3 +57,30 @@ def test_index_values():
     idx = date_range("2019-12-31", periods=3, freq="D")
     result = idx.values
     assert result.flags.writeable is False
+
+
+def test_constructor_copy_input_datetime_ndarray_default():
+    # GH 63388
+    arr = np.array(["2020-01-01", "2020-01-02"], dtype="datetime64[ns]")
+    idx = DatetimeIndex(arr)
+    assert not np.shares_memory(arr, get_array(idx))
+
+
+def test_constructor_copy_input_datetime_ea_default():
+    # GH 63388
+    arr = array(["2020-01-01", "2020-01-02"], dtype="datetime64[ns]")
+    idx = DatetimeIndex(arr)
+    assert not tm.shares_memory(arr, idx.array)
+
+
+def test_series_from_temporary_datetimeindex_readonly_data():
+    # GH 63388
+    arr = np.array(["2020-01-01", "2020-01-02"], dtype="datetime64[ns]")
+    arr.flags.writeable = False
+    ser = Series(DatetimeIndex(arr))
+    assert not np.shares_memory(arr, get_array(ser))
+    ser.iloc[0] = Timestamp("2020-01-01")
+    expected = Series(
+        [Timestamp("2020-01-01"), Timestamp("2020-01-02")], dtype="datetime64[ns]"
+    )
+    tm.assert_series_equal(ser, expected)

pandas/tests/copy_view/index/test_intervalindex.py

@@ -0,0 +1,29 @@
+import numpy as np
+
+from pandas import (
+    Interval,
+    IntervalIndex,
+    Series,
+    array,
+)
+import pandas._testing as tm
+from pandas.tests.copy_view.util import get_array
+
+
+def test_constructor_copy_input_interval_ea_default():
+    # GH 63388
+    arr = array([Interval(0, 1), Interval(1, 2)])
+    idx = IntervalIndex(arr)
+    assert not tm.shares_memory(arr, idx.array)
+
+
+def test_series_from_temporary_intervalindex_readonly_data():
+    # GH 63388
+    arr = array([Interval(0, 1), Interval(1, 2)])
+    arr._left.flags.writeable = False
+    arr._right.flags.writeable = False
+    ser = Series(IntervalIndex(arr))
+    assert not np.shares_memory(arr._left, get_array(ser)._left)
+    ser.iloc[0] = Interval(5, 6)
+    expected = Series([Interval(5, 6), Interval(1, 2)], dtype="interval[int64, right]")
+    tm.assert_series_equal(ser, expected)