TST: dont test private constructors

pandas/core/arrays/datetimes.py

@@ -2308,6 +2308,7 @@ def _sequence_to_dt64ns(
         # assume this data are epoch timestamps
         if data.dtype != INT64_DTYPE:
             data = data.astype(np.int64, copy=False)
+            copy = False
         result = data.view(out_dtype)
 
     if copy:

pandas/tests/arrays/datetimes/test_constructors.py

@@ -8,7 +8,6 @@
 import pandas as pd
 import pandas._testing as tm
 from pandas.core.arrays import DatetimeArray
-from pandas.core.arrays.datetimes import _sequence_to_dt64ns
 
 
 class TestDatetimeArrayConstructor:
@@ -44,7 +43,6 @@ def test_freq_validation(self):
         "meth",
         [
             DatetimeArray._from_sequence,
-            _sequence_to_dt64ns,
             pd.to_datetime,
             pd.DatetimeIndex,
         ],
@@ -104,9 +102,6 @@ def test_bool_dtype_raises(self):
         with pytest.raises(TypeError, match=msg):
             DatetimeArray._from_sequence(arr)
 
-        with pytest.raises(TypeError, match=msg):
-            _sequence_to_dt64ns(arr)
-
         with pytest.raises(TypeError, match=msg):
             pd.DatetimeIndex(arr)
 
@@ -143,14 +138,12 @@ def test_tz_dtype_mismatch_raises(self):
             ["2000"], dtype=DatetimeTZDtype(tz="US/Central")
         )
         with pytest.raises(TypeError, match="data is already tz-aware"):
-            DatetimeArray._from_sequence_not_strict(
-                arr, dtype=DatetimeTZDtype(tz="UTC")
-            )
+            DatetimeArray._from_sequence(arr, dtype=DatetimeTZDtype(tz="UTC"))
 
     def test_tz_dtype_matches(self):
         dtype = DatetimeTZDtype(tz="US/Central")
         arr = DatetimeArray._from_sequence(["2000"], dtype=dtype)
-        result = DatetimeArray._from_sequence_not_strict(arr, dtype=dtype)
+        result = DatetimeArray._from_sequence(arr, dtype=dtype)
         tm.assert_equal(arr, result)
 
     @pytest.mark.parametrize("order", ["F", "C"])
@@ -160,13 +153,6 @@ def test_2d(self, order):
         if order == "F":
             arr = arr.T
 
-        res = _sequence_to_dt64ns(arr)
-        expected = _sequence_to_dt64ns(arr.ravel())
-
-        tm.assert_numpy_array_equal(res[0].ravel(), expected[0])
-        assert res[1] == expected[1]
-        assert res[2] == expected[2]
-
         res = DatetimeArray._from_sequence(arr)
         expected = DatetimeArray._from_sequence(arr.ravel()).reshape(arr.shape)
         tm.assert_datetime_array_equal(res, expected)

pandas/tests/arrays/datetimes/test_cumulative.py

@@ -7,40 +7,35 @@
 class TestAccumulator:
     def test_accumulators_freq(self):
         # GH#50297
-        arr = DatetimeArray._from_sequence_not_strict(
+        arr = DatetimeArray._from_sequence(
             [
                 "2000-01-01",
                 "2000-01-02",
                 "2000-01-03",
-            ],
-            freq="D",
-        )
+            ]
+        )._with_freq("infer")
         result = arr._accumulate("cummin")
-        expected = DatetimeArray._from_sequence_not_strict(
-            ["2000-01-01"] * 3, freq=None
-        )
+        expected = DatetimeArray._from_sequence(["2000-01-01"] * 3)
         tm.assert_datetime_array_equal(result, expected)
 
         result = arr._accumulate("cummax")
-        expected = DatetimeArray._from_sequence_not_strict(
+        expected = DatetimeArray._from_sequence(
             [
                 "2000-01-01",
                 "2000-01-02",
                 "2000-01-03",
             ],
-            freq=None,
         )
         tm.assert_datetime_array_equal(result, expected)
 
     @pytest.mark.parametrize("func", ["cumsum", "cumprod"])
     def test_accumulators_disallowed(self, func):
         # GH#50297
-        arr = DatetimeArray._from_sequence_not_strict(
+        arr = DatetimeArray._from_sequence(
             [
                 "2000-01-01",
                 "2000-01-02",
             ],
-            freq="D",
-        )
+        )._with_freq("infer")
         with pytest.raises(TypeError, match=f"Accumulation {func}"):
             arr._accumulate(func)

pandas/tests/arrays/test_datetimelike.py

@@ -27,8 +27,6 @@
     PeriodArray,
     TimedeltaArray,
 )
-from pandas.core.arrays.datetimes import _sequence_to_dt64ns
-from pandas.core.arrays.timedeltas import sequence_to_td64ns
 
 
 # TODO: more freq variants
@@ -1314,11 +1312,6 @@ def test_from_pandas_array(dtype):
     expected = cls._from_sequence(data)
     tm.assert_extension_array_equal(result, expected)
 
-    func = {"M8[ns]": _sequence_to_dt64ns, "m8[ns]": sequence_to_td64ns}[dtype]
-    result = func(arr)[0]
-    expected = func(data)[0]
-    tm.assert_equal(result, expected)
-
     func = {"M8[ns]": pd.to_datetime, "m8[ns]": pd.to_timedelta}[dtype]
     result = func(arr).array
     expected = func(data).array

pandas/tests/arrays/timedeltas/test_cumulative.py

@@ -7,13 +7,13 @@
 class TestAccumulator:
     def test_accumulators_disallowed(self):
         # GH#50297
-        arr = TimedeltaArray._from_sequence_not_strict(["1D", "2D"])
+        arr = TimedeltaArray._from_sequence(["1D", "2D"])
         with pytest.raises(TypeError, match="cumprod not supported"):
             arr._accumulate("cumprod")
 
     def test_cumsum(self):
         # GH#50297
-        arr = TimedeltaArray._from_sequence_not_strict(["1D", "2D"])
+        arr = TimedeltaArray._from_sequence(["1D", "2D"])
         result = arr._accumulate("cumsum")
-        expected = TimedeltaArray._from_sequence_not_strict(["1D", "3D"])
+        expected = TimedeltaArray._from_sequence(["1D", "3D"])
         tm.assert_timedelta_array_equal(result, expected)

pandas/tests/indexes/datetimes/test_constructors.py

@@ -74,20 +74,17 @@ def test_explicit_tz_none(self):
         with pytest.raises(ValueError, match=msg):
             DatetimeIndex([], dtype="M8[ns, UTC]", tz=None)
 
-    @pytest.mark.parametrize(
-        "dt_cls", [DatetimeIndex, DatetimeArray._from_sequence_not_strict]
-    )
-    def test_freq_validation_with_nat(self, dt_cls):
+    def test_freq_validation_with_nat(self):
         # GH#11587 make sure we get a useful error message when generate_range
         #  raises
         msg = (
             "Inferred frequency None from passed values does not conform "
             "to passed frequency D"
         )
         with pytest.raises(ValueError, match=msg):
-            dt_cls([pd.NaT, Timestamp("2011-01-01")], freq="D")
+            DatetimeIndex([pd.NaT, Timestamp("2011-01-01")], freq="D")
         with pytest.raises(ValueError, match=msg):
-            dt_cls([pd.NaT, Timestamp("2011-01-01")._value], freq="D")
+            DatetimeIndex([pd.NaT, Timestamp("2011-01-01")._value], freq="D")
 
     # TODO: better place for tests shared by DTI/TDI?
     @pytest.mark.parametrize(

pandas/tests/indexes/timedeltas/test_constructors.py

@@ -11,10 +11,7 @@
     to_timedelta,
 )
 import pandas._testing as tm
-from pandas.core.arrays.timedeltas import (
-    TimedeltaArray,
-    sequence_to_td64ns,
-)
+from pandas.core.arrays.timedeltas import TimedeltaArray
 
 
 class TestTimedeltaIndex:
@@ -36,9 +33,6 @@ def test_array_of_dt64_nat_raises(self):
         with pytest.raises(TypeError, match=msg):
             TimedeltaArray._from_sequence(arr)
 
-        with pytest.raises(TypeError, match=msg):
-            sequence_to_td64ns(arr)
-
         with pytest.raises(TypeError, match=msg):
             to_timedelta(arr)
 

pandas/tests/test_downstream.py

@@ -23,8 +23,6 @@
     DatetimeArray,
     TimedeltaArray,
 )
-from pandas.core.arrays.datetimes import _sequence_to_dt64ns
-from pandas.core.arrays.timedeltas import sequence_to_td64ns
 
 
 @pytest.fixture
@@ -316,11 +314,6 @@ def test_from_obscure_array(dtype, array_likes):
     result = cls._from_sequence(data)
     tm.assert_extension_array_equal(result, expected)
 
-    func = {"M8[ns]": _sequence_to_dt64ns, "m8[ns]": sequence_to_td64ns}[dtype]
-    result = func(arr)[0]
-    expected = func(data)[0]
-    tm.assert_equal(result, expected)
-
     if not isinstance(data, memoryview):
         # FIXME(GH#44431) these raise on memoryview and attempted fix
         #  fails on py3.10