fix timestamp replace

Author: jorisvandenbossche

pandas/_libs/tslibs/conversion.pxd

@@ -35,7 +35,8 @@ cdef _TSObject convert_to_tsobject(object ts, tzinfo tz, str unit,
 
 cdef _TSObject convert_datetime_to_tsobject(datetime ts, tzinfo tz,
                                             int32_t nanos=*,
-                                            NPY_DATETIMEUNIT reso=*)
+                                            NPY_DATETIMEUNIT reso=*,
+                                            NPY_DATETIMEUNIT best_reso=*)
 
 cdef _TSObject convert_str_to_tsobject(str ts, tzinfo tz,
                                        bint dayfirst=*,

pandas/_libs/tslibs/conversion.pyx

@@ -423,10 +423,9 @@ cdef _TSObject convert_to_tsobject(object ts, tzinfo tz, str unit,
         return convert_datetime_to_tsobject(ts, tz, nanos, reso=reso)
     elif PyDate_Check(ts):
         # Keep the converter same as PyDateTime's
-        # For date object we give the lowest supported resolution, i.e. "s"
         ts = datetime.combine(ts, time())
         return convert_datetime_to_tsobject(
-            ts, tz, nanos=0, reso=NPY_DATETIMEUNIT.NPY_FR_s
+            ts, tz, nanos=0, reso=NPY_DATETIMEUNIT.NPY_FR_us
         )
     else:
         from .period import Period
@@ -454,7 +453,8 @@ cdef _TSObject convert_datetime_to_tsobject(
     datetime ts,
     tzinfo tz,
     int32_t nanos=0,
-    NPY_DATETIMEUNIT reso=NPY_FR_ns,
+    NPY_DATETIMEUNIT reso=NPY_DATETIMEUNIT.NPY_FR_GENERIC,
+    NPY_DATETIMEUNIT best_reso=NPY_DATETIMEUNIT.NPY_FR_GENERIC,
 ):
     """
     Convert a datetime (or Timestamp) input `ts`, along with optional timezone
@@ -481,7 +481,6 @@ cdef _TSObject convert_datetime_to_tsobject(
         _TSObject obj = _TSObject()
         int64_t pps
 
-    obj.creso = reso
     obj.fold = ts.fold
     if tz is not None:
 
@@ -508,7 +507,8 @@ cdef _TSObject convert_datetime_to_tsobject(
     if nanos:
         obj.dts.ps = nanos * 1000
 
-    reso = get_supported_reso_for_dts(reso, &obj.dts)
+    if reso == NPY_DATETIMEUNIT.NPY_FR_GENERIC:
+        reso = get_supported_reso_for_dts(best_reso, &obj.dts)
     obj.creso = reso
 
     try:
@@ -664,8 +664,13 @@ cdef _TSObject convert_str_to_tsobject(str ts, tzinfo tz,
             out_bestunit=&out_bestunit,
             nanos=&nanos,
         )
-        reso = get_supported_reso(out_bestunit)
-        return convert_datetime_to_tsobject(dt, tz, nanos=nanos, reso=reso)
+        return convert_datetime_to_tsobject(
+            dt,
+            tz,
+            nanos=nanos,
+            reso=NPY_DATETIMEUNIT.NPY_FR_GENERIC,
+            best_reso=out_bestunit
+        )
 
 
 cdef check_overflows(_TSObject obj, NPY_DATETIMEUNIT reso=NPY_FR_ns):

pandas/_libs/tslibs/dtypes.pyx

@@ -530,6 +530,15 @@ cdef NPY_DATETIMEUNIT get_supported_reso_for_dts(
     # defaulting to 'us' if possible.
     if reso == NPY_DATETIMEUNIT.NPY_FR_GENERIC:
         return NPY_DATETIMEUNIT.NPY_FR_ns
+        # if dts.ps != 0:
+        #     return NPY_DATETIMEUNIT.NPY_FR_ns
+        # elif (
+        #     cmp_dtstructs(dts, &dts_us_min, Py_GE)
+        #     and cmp_dtstructs(dts, &dts_us_max, Py_LE)
+        # ):
+        #     return NPY_DATETIMEUNIT.NPY_FR_us
+        # else:
+        #     return NPY_DATETIMEUNIT.NPY_FR_s
     if reso < NPY_DATETIMEUNIT.NPY_FR_us:
         if (
             cmp_dtstructs(dts, &dts_us_min, Py_GE)

pandas/tests/indexes/datetimes/test_constructors.py

@@ -1093,6 +1093,19 @@ def test_dti_constructor_with_dtype_object_int_matches_int_dtype(self, dtype):
         tm.assert_index_equal(res3, expected)
         tm.assert_index_equal(res4, expected)
 
+    @pytest.mark.parametrize("tz", [None, "US/Eastern"])
+    def test_constructor_from_timestamp_objects(self, unit, tz):
+        result = DatetimeIndex(
+            [
+                Timestamp("2012-01-01 00:00:00", tz=tz).as_unit(unit),
+                Timestamp("2012-01-02 00:00:00", tz=tz).as_unit(unit),
+            ],
+        )
+        expected = (
+            DatetimeIndex(["2012-01-01", "2012-01-02"]).as_unit(unit).tz_localize(tz)
+        )
+        tm.assert_index_equal(result, expected)
+
 
 class TestTimeSeries:
     def test_dti_constructor_preserve_dti_freq(self):

pandas/tests/scalar/timestamp/methods/test_tz_localize.py

@@ -72,7 +72,7 @@ def test_tz_localize_ambiguous(self):
         ts_dst = ts.tz_localize("US/Eastern", ambiguous=True)
         ts_no_dst = ts.tz_localize("US/Eastern", ambiguous=False)
 
-        assert ts_no_dst._value - ts_dst._value == 3600
+        assert ts_no_dst._value - ts_dst._value == 3600_000_000
         msg = re.escape(
             "'ambiguous' parameter must be one of: "
             "True, False, 'NaT', 'raise' (default)"
@@ -140,7 +140,7 @@ def test_tz_localize_nonexistent(self, stamp, tz):
     def test_tz_localize_nonexistent_shift(
         self, stamp, tz, forward_expected, backward_expected
     ):
-        ts = Timestamp(stamp)
+        ts = Timestamp(stamp).as_unit("s")
         forward_ts = ts.tz_localize(tz, nonexistent="shift_forward")
         assert forward_ts == Timestamp(forward_expected, tz=tz)
         backward_ts = ts.tz_localize(tz, nonexistent="shift_backward")
@@ -198,7 +198,7 @@ def test_tz_localize_ambiguous_compat(self):
         result_pytz = naive.tz_localize(pytz_zone, ambiguous=False)
         result_dateutil = naive.tz_localize(dateutil_zone, ambiguous=False)
         assert result_pytz._value == result_dateutil._value
-        assert result_pytz._value == 1382835600
+        assert result_pytz._value == 1382835600000000
 
         # fixed ambiguous behavior
         # see gh-14621, GH#45087
@@ -210,7 +210,7 @@ def test_tz_localize_ambiguous_compat(self):
         result_pytz = naive.tz_localize(pytz_zone, ambiguous=True)
         result_dateutil = naive.tz_localize(dateutil_zone, ambiguous=True)
         assert result_pytz._value == result_dateutil._value
-        assert result_pytz._value == 1382832000
+        assert result_pytz._value == 1382832000000000
 
         # see gh-14621
         assert str(result_pytz) == str(result_dateutil)

pandas/tests/scalar/timestamp/test_constructors.py

@@ -424,31 +424,31 @@ class TestTimestampResolutionInference:
     def test_construct_from_time_unit(self):
         # GH#54097 only passing a time component, no date
         ts = Timestamp("01:01:01.111")
-        assert ts.unit == "ms"
+        assert ts.unit == "us"
 
     def test_constructor_str_infer_reso(self):
         # non-iso8601 path
 
         # _parse_delimited_date path
         ts = Timestamp("01/30/2023")
-        assert ts.unit == "s"
+        assert ts.unit == "us"
 
         # _parse_dateabbr_string path
         ts = Timestamp("2015Q1")
-        assert ts.unit == "s"
+        assert ts.unit == "us"
 
         # dateutil_parse path
         ts = Timestamp("2016-01-01 1:30:01 PM")
-        assert ts.unit == "s"
+        assert ts.unit == "us"
 
         ts = Timestamp("2016 June 3 15:25:01.345")
-        assert ts.unit == "ms"
+        assert ts.unit == "us"
 
         ts = Timestamp("300-01-01")
-        assert ts.unit == "s"
+        assert ts.unit == "us"
 
         ts = Timestamp("300 June 1:30:01.300")
-        assert ts.unit == "ms"
+        assert ts.unit == "us"
 
         # dateutil path -> don't drop trailing zeros
         ts = Timestamp("01-01-2013T00:00:00.000000000+0000")
@@ -464,10 +464,10 @@ def test_constructor_str_infer_reso(self):
 
         # GH#56208 minute reso through the ISO8601 path with tz offset
         ts = Timestamp("2020-01-01 00:00+00:00")
-        assert ts.unit == "s"
+        assert ts.unit == "us"
 
         ts = Timestamp("2020-01-01 00+00:00")
-        assert ts.unit == "s"
+        assert ts.unit == "us"
 
     @pytest.mark.parametrize("method", ["now", "today"])
     def test_now_today_unit(self, method):
@@ -504,10 +504,10 @@ def test_construct_from_string_invalid_raises(self):
     def test_constructor_from_iso8601_str_with_offset_reso(self):
         # GH#49737
         ts = Timestamp("2016-01-01 04:05:06-01:00")
-        assert ts.unit == "s"
+        assert ts.unit == "us"
 
         ts = Timestamp("2016-01-01 04:05:06.000-01:00")
-        assert ts.unit == "ms"
+        assert ts.unit == "us"
 
         ts = Timestamp("2016-01-01 04:05:06.000000-01:00")
         assert ts.unit == "us"
@@ -520,7 +520,7 @@ def test_constructor_from_date_second_reso(self):
         #  reso, i.e. seconds
         obj = date(2012, 9, 1)
         ts = Timestamp(obj)
-        assert ts.unit == "s"
+        assert ts.unit == "us"
 
     def test_constructor_datetime64_with_tz(self):
         # GH#42288, GH#24559
@@ -820,10 +820,10 @@ def test_out_of_bounds_string(self):
             Timestamp("2263-01-01").as_unit("ns")
 
         ts = Timestamp("2263-01-01")
-        assert ts.unit == "s"
+        assert ts.unit == "us"
 
         ts = Timestamp("1676-01-01")
-        assert ts.unit == "s"
+        assert ts.unit == "us"
 
     def test_barely_out_of_bounds(self):
         # GH#19529
@@ -874,7 +874,7 @@ def test_out_of_bounds_string_consistency(self, arg):
             Timestamp(arg).as_unit("ns")
 
         ts = Timestamp(arg)
-        assert ts.unit == "s"
+        assert ts.unit == "us"
         assert ts.year == ts.month == ts.day == 1
 
     def test_min_valid(self):
@@ -1067,22 +1067,22 @@ def test_timestamp_nano_range(nano):
 
 def test_non_nano_value():
     # https://github.com/pandas-dev/pandas/issues/49076
-    result = Timestamp("1800-01-01", unit="s").value
+    result = Timestamp("1800-01-01").value
     # `.value` shows nanoseconds, even though unit is 's'
     assert result == -5364662400000000000
 
     # out-of-nanoseconds-bounds `.value` raises informative message
     msg = (
         r"Cannot convert Timestamp to nanoseconds without overflow. "
         r"Use `.asm8.view\('i8'\)` to cast represent Timestamp in its "
-        r"own unit \(here, s\).$"
+        r"own unit \(here, us\).$"
     )
     ts = Timestamp("0300-01-01")
     with pytest.raises(OverflowError, match=msg):
         ts.value
     # check that the suggested workaround actually works
     result = ts.asm8.view("i8")
-    assert result == -52700112000
+    assert result == -52700112000000000
 
 
 @pytest.mark.parametrize("na_value", [None, np.nan, np.datetime64("NaT"), NaT, NA])