Rework

Author: rhshadrach

doc/source/whatsnew/v2.2.2.rst

@@ -16,6 +16,7 @@ Fixed regressions
 - :meth:`DataFrame.__dataframe__` was producing incorrect data buffers when the a column's type was a pandas nullable on with missing values (:issue:`56702`)
 - :meth:`DataFrame.__dataframe__` was producing incorrect data buffers when the a column's type was a pyarrow nullable on with missing values (:issue:`57664`)
 - Avoid issuing a spurious ``DeprecationWarning`` when a custom :class:`DataFrame` or :class:`Series` subclass method is called (:issue:`57553`)
+- Fixed regression in :meth:`Index.map` that would not change the dtype when the provided mapping would change data from tz-aware to tz-agnostic or tz-agnostic to tz-aware (:issue:`57192`)
 - Fixed regression in precision of :func:`to_datetime` with string and ``unit`` input (:issue:`57051`)
 
 .. ---------------------------------------------------------------------------

pandas/_libs/lib.pyi

@@ -54,6 +54,7 @@ def is_timedelta_or_timedelta64_array(
     values: np.ndarray, skipna: bool = True
 ) -> bool: ...
 def is_datetime_with_singletz_array(values: np.ndarray) -> bool: ...
+def is_datetime_naive_array(values: np.ndarray) -> bool: ...
 def is_time_array(values: np.ndarray, skipna: bool = ...): ...
 def is_date_array(values: np.ndarray, skipna: bool = ...): ...
 def is_datetime_array(values: np.ndarray, skipna: bool = ...): ...

pandas/_libs/lib.pyx

@@ -2068,6 +2068,30 @@ def is_datetime_with_singletz_array(values: ndarray) -> bool:
     return True
 
 
+def is_datetime_naive_array(values: ndarray) -> bool:
+    """
+    Check values have are datetime naive.
+    Doesn't check values are datetime-like types.
+    """
+    cdef:
+        Py_ssize_t j, n = len(values)
+        object tz
+
+    if n == 0:
+        return False
+
+    for j in range(n):
+        # Compare val's timezone with the reference timezone
+        # NaT can coexist with tz-aware datetimes, so skip if encountered
+        # val = values[j]
+        # if val is not NaT and val is not None and not util.is_nan(val):
+        tz = getattr(values[j], "tzinfo", None)
+        if tz is not None:
+            return False
+
+    return True
+
+
 @cython.internal
 cdef class TimedeltaValidator(TemporalValidator):
     cdef bint is_value_typed(self, object value) except -1:

pandas/core/arrays/datetimes.py

@@ -290,9 +290,15 @@ def _scalar_type(self) -> type[Timestamp]:
 
     @classmethod
     def _from_scalars(cls, scalars, *, dtype: DtypeObj) -> Self:
-        if lib.infer_dtype(scalars, skipna=True) not in ["datetime", "datetime64"]:
-            # TODO: require any NAs be valid-for-DTA
-            # TODO: if dtype is passed, check for tzawareness compat?
+        # TODO: require any NAs be valid-for-DTA
+        # TODO: if dtype is passed, check for tzawareness compat?
+        if not lib.is_datetime64_array(scalars):
+            raise ValueError
+        elif isinstance(
+            dtype, DatetimeTZDtype
+        ) and not lib.is_datetime_with_singletz_array(scalars):
+            raise ValueError
+        elif isinstance(dtype, np.dtype) and not lib.is_datetime_naive_array(scalars):
             raise ValueError
         return cls._from_sequence(scalars, dtype=dtype)
 

pandas/core/indexes/base.py

@@ -6103,16 +6103,14 @@ def map(self, mapper, na_action: Literal["ignore"] | None = None):
             # empty
             dtype = self.dtype
 
-        if self.inferred_type != "datetime64":
-            # e.g. if we are floating and new_values is all ints, then we
-            #  don't want to cast back to floating.  But if we are UInt64
-            #  and new_values is all ints, we want to try.
-            # GH#57192 - we skip datetime64 because inference from values is reliable
-            same_dtype = lib.infer_dtype(new_values, skipna=False) == self.inferred_type
-            if same_dtype:
-                new_values = maybe_cast_pointwise_result(
-                    new_values, self.dtype, same_dtype=same_dtype
-                )
+        # e.g. if we are floating and new_values is all ints, then we
+        #  don't want to cast back to floating.  But if we are UInt64
+        #  and new_values is all ints, we want to try.
+        same_dtype = lib.infer_dtype(new_values, skipna=False) == self.inferred_type
+        if same_dtype:
+            new_values = maybe_cast_pointwise_result(
+                new_values, self.dtype, same_dtype=same_dtype
+            )
 
         return Index._with_infer(new_values, dtype=dtype, copy=False, name=self.name)