REF: move freq handling out of DTA._from_sequence_not_strict, move _with_freq logic to Index

- Remove freq parameter from DTA._from_sequence_not_strict; it no longer
  reads data.freq or calls _maybe_pin_freq
- DTI.__new__ now extracts freq from incoming data and calls _maybe_pin_freq
  externally, following the pattern established for TDI in pandas-dev#65162
- Move _with_freq freq-resolution logic to DatetimeTimedeltaMixin._with_freq
  so the Index resolves "infer" before delegating to the array
- Relax array _with_freq to accept BaseOffset on non-empty arrays (needed
  since the Index now resolves "infer" to an offset before passing down)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: jbrockmendel

pandas/core/arrays/datetimelike.py

@@ -1865,8 +1865,7 @@ def freq(self, value) -> None:
     def _maybe_pin_freq(self, freq, validate_kwds: dict) -> None:
         """
         Constructor helper to pin the appropriate `freq` attribute.  Assumes
-        that self._freq is currently set to any freq inferred in
-        _from_sequence_not_strict.
+        that self._freq is currently set to any freq inferred from input data.
         """
         if freq is None:
             # user explicitly passed None -> override any inferred_freq
@@ -2466,14 +2465,14 @@ def _with_freq(self, freq) -> Self:
         if freq is None:
             # Always valid
             pass
-        elif len(self) == 0 and isinstance(freq, BaseOffset):
-            # Always valid.  In the TimedeltaArray case, we require a Tick offset
+        elif isinstance(freq, BaseOffset):
+            # In the TimedeltaArray case, we require a Tick offset
             if self.dtype.kind == "m" and not isinstance(freq, (Tick, Day)):
                 raise TypeError("TimedeltaArray/Index freq must be a Tick")
-        else:
-            # As an internal method, we can ensure this assertion always holds
-            assert freq == "infer"
+        elif freq == "infer":
             freq = to_offset(self.inferred_freq)
+        else:
+            raise ValueError(f"Invalid frequency: {freq!r}")
 
         arr = self.view()
         arr._freq = freq

pandas/core/arrays/datetimes.py

@@ -332,7 +332,6 @@ def _from_sequence_not_strict(
         dtype=None,
         copy: bool = False,
         tz=lib.no_default,
-        freq: str | BaseOffset | lib.NoDefault | None = lib.no_default,
         dayfirst: bool = False,
         yearfirst: bool = False,
         ambiguous: TimeAmbiguous = "raise",
@@ -360,9 +359,6 @@ def _from_sequence_not_strict(
         data, copy = dtl.ensure_arraylike_for_datetimelike(
             data, copy, cls_name="DatetimeArray"
         )
-        inferred_freq = None
-        if isinstance(data, DatetimeArray):
-            inferred_freq = data.freq
 
         subarr, tz = _sequence_to_dt64(
             data,
@@ -384,16 +380,14 @@ def _from_sequence_not_strict(
         data_unit = np.datetime_data(subarr.dtype)[0]
         data_unit = cast("TimeUnit", data_unit)
         data_dtype = tz_to_dtype(tz, data_unit)
-        result = cls._simple_new(subarr, freq=inferred_freq, dtype=data_dtype)
+        result = cls._simple_new(subarr, dtype=data_dtype)
         if unit is not None and unit != result.unit:
             # If unit was specified in user-passed dtype, cast to it here
             # error: Argument 1 to "as_unit" of "TimelikeOps" has
             # incompatible type "str"; expected "Literal['s', 'ms', 'us', 'ns']"
             # [arg-type]
             result = result.as_unit(unit)  # type: ignore[arg-type]
 
-        validate_kwds = {"ambiguous": ambiguous}
-        result._maybe_pin_freq(freq, validate_kwds)
         return result
 
     @classmethod

pandas/core/indexes/datetimelike.py

@@ -849,6 +849,19 @@ def as_unit(self, unit: TimeUnit) -> Self:
         return result
 
     def _with_freq(self, freq):
+        # GH#29843
+        if freq is None:
+            # Always valid
+            pass
+        elif len(self) == 0 and isinstance(freq, BaseOffset):
+            # Always valid.  In the TimedeltaArray case, we require a Tick offset
+            if self.dtype.kind == "m" and not isinstance(freq, (Tick, Day)):
+                raise TypeError("TimedeltaArray/Index freq must be a Tick")
+        else:
+            # As an internal method, we can ensure this assertion always holds
+            assert freq == "infer"
+            freq = to_offset(self.inferred_freq)
+
         arr = self._data._with_freq(freq)
         return type(self)._simple_new(arr, name=self._name)
 

pandas/core/indexes/datetimes.py

@@ -901,16 +901,29 @@ def __new__(
                 data = data.copy()
             return cls._simple_new(data, name=name)
 
+        # Extract freq from incoming data before array conversion strips it
+        inferred_freq = None
+        if isinstance(data, DatetimeArray):
+            inferred_freq = data.freq
+        elif isinstance(data, (Index, ABCSeries)):
+            values = data._values
+            if isinstance(values, DatetimeArray):
+                inferred_freq = values.freq
+
         dtarr = DatetimeArray._from_sequence_not_strict(
             data,
             dtype=dtype,
             copy=copy,
             tz=tz,
-            freq=freq,
             dayfirst=dayfirst,
             yearfirst=yearfirst,
             ambiguous=ambiguous,
         )
+
+        if inferred_freq is not None:
+            dtarr._freq = inferred_freq
+        dtarr._maybe_pin_freq(freq, {"ambiguous": ambiguous})
+
         refs = None
         if not copy and isinstance(data, (Index, ABCSeries)):
             refs = data._references