From bc03b329726e9481e46f631476fd3000725aa2b7 Mon Sep 17 00:00:00 2001 From: Brock Date: Tue, 24 Oct 2023 16:47:25 -0700 Subject: [PATCH 1/2] REF: collect Timestamp tests by method --- .../scalar/timestamp/methods/test_as_unit.py | 86 ++++ .../timestamp/methods/test_normalize.py | 22 ++ .../scalar/timestamp/methods/test_replace.py | 193 +++++++++ .../test_round.py} | 228 +---------- .../methods/test_timestamp_method.py | 31 ++ .../timestamp/methods/test_to_julian_date.py | 28 ++ .../timestamp/methods/test_to_pydatetime.py | 81 ++++ .../timestamp/methods/test_tz_convert.py | 57 +++ .../timestamp/methods/test_tz_localize.py | 312 +++++++++++++++ .../tests/scalar/timestamp/test_arithmetic.py | 44 +++ pandas/tests/scalar/timestamp/test_formats.py | 119 ++++++ .../tests/scalar/timestamp/test_rendering.py | 122 ------ .../tests/scalar/timestamp/test_timestamp.py | 224 +---------- .../tests/scalar/timestamp/test_timezones.py | 371 +----------------- 14 files changed, 977 insertions(+), 941 deletions(-) create mode 100644 pandas/tests/scalar/timestamp/methods/test_as_unit.py create mode 100644 pandas/tests/scalar/timestamp/methods/test_normalize.py create mode 100644 pandas/tests/scalar/timestamp/methods/test_replace.py rename pandas/tests/scalar/timestamp/{test_unary_ops.py => methods/test_round.py} (60%) create mode 100644 pandas/tests/scalar/timestamp/methods/test_timestamp_method.py create mode 100644 pandas/tests/scalar/timestamp/methods/test_to_julian_date.py create mode 100644 pandas/tests/scalar/timestamp/methods/test_to_pydatetime.py create mode 100644 pandas/tests/scalar/timestamp/methods/test_tz_convert.py create mode 100644 pandas/tests/scalar/timestamp/methods/test_tz_localize.py delete mode 100644 pandas/tests/scalar/timestamp/test_rendering.py diff --git a/pandas/tests/scalar/timestamp/methods/test_as_unit.py b/pandas/tests/scalar/timestamp/methods/test_as_unit.py new file mode 100644 index 0000000000000..5572c5936fb12 --- /dev/null +++ b/pandas/tests/scalar/timestamp/methods/test_as_unit.py @@ -0,0 +1,86 @@ +import pytest + +from pandas._libs.tslibs.dtypes import NpyDatetimeUnit +from pandas.errors import OutOfBoundsDatetime + +from pandas import Timestamp + + +class TestTimestampAsUnit: + def test_as_unit(self): + ts = Timestamp("1970-01-01").as_unit("ns") + assert ts.unit == "ns" + + assert ts.as_unit("ns") is ts + + res = ts.as_unit("us") + assert res._value == ts._value // 1000 + assert res._creso == NpyDatetimeUnit.NPY_FR_us.value + + rt = res.as_unit("ns") + assert rt._value == ts._value + assert rt._creso == ts._creso + + res = ts.as_unit("ms") + assert res._value == ts._value // 1_000_000 + assert res._creso == NpyDatetimeUnit.NPY_FR_ms.value + + rt = res.as_unit("ns") + assert rt._value == ts._value + assert rt._creso == ts._creso + + res = ts.as_unit("s") + assert res._value == ts._value // 1_000_000_000 + assert res._creso == NpyDatetimeUnit.NPY_FR_s.value + + rt = res.as_unit("ns") + assert rt._value == ts._value + assert rt._creso == ts._creso + + def test_as_unit_overflows(self): + # microsecond that would be just out of bounds for nano + us = 9223372800000000 + ts = Timestamp._from_value_and_reso(us, NpyDatetimeUnit.NPY_FR_us.value, None) + + msg = "Cannot cast 2262-04-12 00:00:00 to unit='ns' without overflow" + with pytest.raises(OutOfBoundsDatetime, match=msg): + ts.as_unit("ns") + + res = ts.as_unit("ms") + assert res._value == us // 1000 + assert res._creso == NpyDatetimeUnit.NPY_FR_ms.value + + def test_as_unit_rounding(self): + ts = Timestamp(1_500_000) # i.e. 1500 microseconds + res = ts.as_unit("ms") + + expected = Timestamp(1_000_000) # i.e. 1 millisecond + assert res == expected + + assert res._creso == NpyDatetimeUnit.NPY_FR_ms.value + assert res._value == 1 + + with pytest.raises(ValueError, match="Cannot losslessly convert units"): + ts.as_unit("ms", round_ok=False) + + def test_as_unit_non_nano(self): + # case where we are going neither to nor from nano + ts = Timestamp("1970-01-02").as_unit("ms") + assert ts.year == 1970 + assert ts.month == 1 + assert ts.day == 2 + assert ts.hour == ts.minute == ts.second == ts.microsecond == ts.nanosecond == 0 + + res = ts.as_unit("s") + assert res._value == 24 * 3600 + assert res.year == 1970 + assert res.month == 1 + assert res.day == 2 + assert ( + res.hour + == res.minute + == res.second + == res.microsecond + == res.nanosecond + == 0 + ) diff --git a/pandas/tests/scalar/timestamp/methods/test_normalize.py b/pandas/tests/scalar/timestamp/methods/test_normalize.py new file mode 100644 index 0000000000000..e097c9673e17a --- /dev/null +++ b/pandas/tests/scalar/timestamp/methods/test_normalize.py @@ -0,0 +1,22 @@ +import pytest + +from pandas._libs.tslibs import Timestamp +from pandas._libs.tslibs.dtypes import NpyDatetimeUnit + + +class TestTimestampNormalize: + @pytest.mark.parametrize("arg", ["2013-11-30", "2013-11-30 12:00:00"]) + @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s"]) + def test_normalize(self, tz_naive_fixture, arg, unit): + tz = tz_naive_fixture + ts = Timestamp(arg, tz=tz).as_unit(unit) + result = ts.normalize() + expected = Timestamp("2013-11-30", tz=tz) + assert result == expected + assert result._creso == getattr(NpyDatetimeUnit, f"NPY_FR_{unit}").value + + def test_normalize_pre_epoch_dates(self): + # GH: 36294 + result = Timestamp("1969-01-01 09:00:00").normalize() + expected = Timestamp("1969-01-01 00:00:00") + assert result == expected diff --git a/pandas/tests/scalar/timestamp/methods/test_replace.py b/pandas/tests/scalar/timestamp/methods/test_replace.py new file mode 100644 index 0000000000000..9b2b21cf7f388 --- /dev/null +++ b/pandas/tests/scalar/timestamp/methods/test_replace.py @@ -0,0 +1,193 @@ +from datetime import datetime + +from dateutil.tz import gettz +import numpy as np +import pytest +import pytz + +from pandas._libs.tslibs import ( + OutOfBoundsDatetime, + Timestamp, + conversion, +) +from pandas._libs.tslibs.dtypes import NpyDatetimeUnit +import pandas.util._test_decorators as td + +import pandas._testing as tm + + +class TestTimestampReplace: + def test_replace_out_of_pydatetime_bounds(self): + # GH#50348 + ts = Timestamp("2016-01-01").as_unit("ns") + + msg = "Out of bounds nanosecond timestamp: 99999-01-01 00:00:00" + with pytest.raises(OutOfBoundsDatetime, match=msg): + ts.replace(year=99_999) + + ts = ts.as_unit("ms") + result = ts.replace(year=99_999) + assert result.year == 99_999 + assert result._value == Timestamp(np.datetime64("99999-01-01", "ms"))._value + + def test_replace_non_nano(self): + ts = Timestamp._from_value_and_reso( + 91514880000000000, NpyDatetimeUnit.NPY_FR_us.value, None + ) + assert ts.to_pydatetime() == datetime(4869, 12, 28) + + result = ts.replace(year=4900) + assert result._creso == ts._creso + assert result.to_pydatetime() == datetime(4900, 12, 28) + + def test_replace_naive(self): + # GH#14621, GH#7825 + ts = Timestamp("2016-01-01 09:00:00") + result = ts.replace(hour=0) + expected = Timestamp("2016-01-01 00:00:00") + assert result == expected + + def test_replace_aware(self, tz_aware_fixture): + tz = tz_aware_fixture + # GH#14621, GH#7825 + # replacing datetime components with and w/o presence of a timezone + ts = Timestamp("2016-01-01 09:00:00", tz=tz) + result = ts.replace(hour=0) + expected = Timestamp("2016-01-01 00:00:00", tz=tz) + assert result == expected + + def test_replace_preserves_nanos(self, tz_aware_fixture): + tz = tz_aware_fixture + # GH#14621, GH#7825 + ts = Timestamp("2016-01-01 09:00:00.000000123", tz=tz) + result = ts.replace(hour=0) + expected = Timestamp("2016-01-01 00:00:00.000000123", tz=tz) + assert result == expected + + def test_replace_multiple(self, tz_aware_fixture): + tz = tz_aware_fixture + # GH#14621, GH#7825 + # replacing datetime components with and w/o presence of a timezone + # test all + ts = Timestamp("2016-01-01 09:00:00.000000123", tz=tz) + result = ts.replace( + year=2015, + month=2, + day=2, + hour=0, + minute=5, + second=5, + microsecond=5, + nanosecond=5, + ) + expected = Timestamp("2015-02-02 00:05:05.000005005", tz=tz) + assert result == expected + + def test_replace_invalid_kwarg(self, tz_aware_fixture): + tz = tz_aware_fixture + # GH#14621, GH#7825 + ts = Timestamp("2016-01-01 09:00:00.000000123", tz=tz) + msg = r"replace\(\) got an unexpected keyword argument" + with pytest.raises(TypeError, match=msg): + ts.replace(foo=5) + + def test_replace_integer_args(self, tz_aware_fixture): + tz = tz_aware_fixture + # GH#14621, GH#7825 + ts = Timestamp("2016-01-01 09:00:00.000000123", tz=tz) + msg = "value must be an integer, received for hour" + with pytest.raises(ValueError, match=msg): + ts.replace(hour=0.1) + + def test_replace_tzinfo_equiv_tz_localize_none(self): + # GH#14621, GH#7825 + # assert conversion to naive is the same as replacing tzinfo with None + ts = Timestamp("2013-11-03 01:59:59.999999-0400", tz="US/Eastern") + assert ts.tz_localize(None) == ts.replace(tzinfo=None) + + @td.skip_if_windows + def test_replace_tzinfo(self): + # GH#15683 + dt = datetime(2016, 3, 27, 1) + tzinfo = pytz.timezone("CET").localize(dt, is_dst=False).tzinfo + + result_dt = dt.replace(tzinfo=tzinfo) + result_pd = Timestamp(dt).replace(tzinfo=tzinfo) + + # datetime.timestamp() converts in the local timezone + with tm.set_timezone("UTC"): + assert result_dt.timestamp() == result_pd.timestamp() + + assert result_dt == result_pd + assert result_dt == result_pd.to_pydatetime() + + result_dt = dt.replace(tzinfo=tzinfo).replace(tzinfo=None) + result_pd = Timestamp(dt).replace(tzinfo=tzinfo).replace(tzinfo=None) + + # datetime.timestamp() converts in the local timezone + with tm.set_timezone("UTC"): + assert result_dt.timestamp() == result_pd.timestamp() + + assert result_dt == result_pd + assert result_dt == result_pd.to_pydatetime() + + @pytest.mark.parametrize( + "tz, normalize", + [ + (pytz.timezone("US/Eastern"), lambda x: x.tzinfo.normalize(x)), + (gettz("US/Eastern"), lambda x: x), + ], + ) + def test_replace_across_dst(self, tz, normalize): + # GH#18319 check that 1) timezone is correctly normalized and + # 2) that hour is not incorrectly changed by this normalization + ts_naive = Timestamp("2017-12-03 16:03:30") + ts_aware = conversion.localize_pydatetime(ts_naive, tz) + + # Preliminary sanity-check + assert ts_aware == normalize(ts_aware) + + # Replace across DST boundary + ts2 = ts_aware.replace(month=6) + + # Check that `replace` preserves hour literal + assert (ts2.hour, ts2.minute) == (ts_aware.hour, ts_aware.minute) + + # Check that post-replace object is appropriately normalized + ts2b = normalize(ts2) + assert ts2 == ts2b + + @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s"]) + def test_replace_dst_border(self, unit): + # Gh 7825 + t = Timestamp("2013-11-3", tz="America/Chicago").as_unit(unit) + result = t.replace(hour=3) + expected = Timestamp("2013-11-3 03:00:00", tz="America/Chicago") + assert result == expected + assert result._creso == getattr(NpyDatetimeUnit, f"NPY_FR_{unit}").value + + @pytest.mark.parametrize("fold", [0, 1]) + @pytest.mark.parametrize("tz", ["dateutil/Europe/London", "Europe/London"]) + @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s"]) + def test_replace_dst_fold(self, fold, tz, unit): + # GH 25017 + d = datetime(2019, 10, 27, 2, 30) + ts = Timestamp(d, tz=tz).as_unit(unit) + result = ts.replace(hour=1, fold=fold) + expected = Timestamp(datetime(2019, 10, 27, 1, 30)).tz_localize( + tz, ambiguous=not fold + ) + assert result == expected + assert result._creso == getattr(NpyDatetimeUnit, f"NPY_FR_{unit}").value + + @pytest.mark.parametrize("fold", [0, 1]) + def test_replace_preserves_fold(self, fold): + # GH#37610. Check that replace preserves Timestamp fold property + tz = gettz("Europe/Moscow") + + ts = Timestamp( + year=2009, month=10, day=25, hour=2, minute=30, fold=fold, tzinfo=tz + ) + ts_replaced = ts.replace(second=1) + + assert ts_replaced.fold == fold diff --git a/pandas/tests/scalar/timestamp/test_unary_ops.py b/pandas/tests/scalar/timestamp/methods/test_round.py similarity index 60% rename from pandas/tests/scalar/timestamp/test_unary_ops.py rename to pandas/tests/scalar/timestamp/methods/test_round.py index b7d5bbe71269a..d10ee18b47f19 100644 --- a/pandas/tests/scalar/timestamp/test_unary_ops.py +++ b/pandas/tests/scalar/timestamp/methods/test_round.py @@ -1,6 +1,3 @@ -from datetime import datetime - -from dateutil.tz import gettz from hypothesis import ( given, strategies as st, @@ -8,7 +5,6 @@ import numpy as np import pytest import pytz -from pytz import utc from pandas._libs import lib from pandas._libs.tslibs import ( @@ -16,19 +12,16 @@ OutOfBoundsDatetime, Timedelta, Timestamp, - conversion, iNaT, to_offset, ) from pandas._libs.tslibs.dtypes import NpyDatetimeUnit from pandas._libs.tslibs.period import INVALID_FREQ_ERR_MSG -import pandas.util._test_decorators as td import pandas._testing as tm -class TestTimestampUnaryOps: - # -------------------------------------------------------------- +class TestTimestampRound: def test_round_division_by_zero_raises(self): ts = Timestamp("2016-01-01") @@ -36,7 +29,6 @@ def test_round_division_by_zero_raises(self): with pytest.raises(ValueError, match=msg): ts.round("0ns") - # Timestamp.round @pytest.mark.parametrize( "timestamp, freq, expected", [ @@ -389,221 +381,3 @@ def checker(ts, nanos, unit): nanos = 24 * 60 * 60 * 1_000_000_000 checker(ts, nanos, "D") - - # -------------------------------------------------------------- - # Timestamp.replace - - def test_replace_out_of_pydatetime_bounds(self): - # GH#50348 - ts = Timestamp("2016-01-01").as_unit("ns") - - msg = "Out of bounds nanosecond timestamp: 99999-01-01 00:00:00" - with pytest.raises(OutOfBoundsDatetime, match=msg): - ts.replace(year=99_999) - - ts = ts.as_unit("ms") - result = ts.replace(year=99_999) - assert result.year == 99_999 - assert result._value == Timestamp(np.datetime64("99999-01-01", "ms"))._value - - def test_replace_non_nano(self): - ts = Timestamp._from_value_and_reso( - 91514880000000000, NpyDatetimeUnit.NPY_FR_us.value, None - ) - assert ts.to_pydatetime() == datetime(4869, 12, 28) - - result = ts.replace(year=4900) - assert result._creso == ts._creso - assert result.to_pydatetime() == datetime(4900, 12, 28) - - def test_replace_naive(self): - # GH#14621, GH#7825 - ts = Timestamp("2016-01-01 09:00:00") - result = ts.replace(hour=0) - expected = Timestamp("2016-01-01 00:00:00") - assert result == expected - - def test_replace_aware(self, tz_aware_fixture): - tz = tz_aware_fixture - # GH#14621, GH#7825 - # replacing datetime components with and w/o presence of a timezone - ts = Timestamp("2016-01-01 09:00:00", tz=tz) - result = ts.replace(hour=0) - expected = Timestamp("2016-01-01 00:00:00", tz=tz) - assert result == expected - - def test_replace_preserves_nanos(self, tz_aware_fixture): - tz = tz_aware_fixture - # GH#14621, GH#7825 - ts = Timestamp("2016-01-01 09:00:00.000000123", tz=tz) - result = ts.replace(hour=0) - expected = Timestamp("2016-01-01 00:00:00.000000123", tz=tz) - assert result == expected - - def test_replace_multiple(self, tz_aware_fixture): - tz = tz_aware_fixture - # GH#14621, GH#7825 - # replacing datetime components with and w/o presence of a timezone - # test all - ts = Timestamp("2016-01-01 09:00:00.000000123", tz=tz) - result = ts.replace( - year=2015, - month=2, - day=2, - hour=0, - minute=5, - second=5, - microsecond=5, - nanosecond=5, - ) - expected = Timestamp("2015-02-02 00:05:05.000005005", tz=tz) - assert result == expected - - def test_replace_invalid_kwarg(self, tz_aware_fixture): - tz = tz_aware_fixture - # GH#14621, GH#7825 - ts = Timestamp("2016-01-01 09:00:00.000000123", tz=tz) - msg = r"replace\(\) got an unexpected keyword argument" - with pytest.raises(TypeError, match=msg): - ts.replace(foo=5) - - def test_replace_integer_args(self, tz_aware_fixture): - tz = tz_aware_fixture - # GH#14621, GH#7825 - ts = Timestamp("2016-01-01 09:00:00.000000123", tz=tz) - msg = "value must be an integer, received for hour" - with pytest.raises(ValueError, match=msg): - ts.replace(hour=0.1) - - def test_replace_tzinfo_equiv_tz_localize_none(self): - # GH#14621, GH#7825 - # assert conversion to naive is the same as replacing tzinfo with None - ts = Timestamp("2013-11-03 01:59:59.999999-0400", tz="US/Eastern") - assert ts.tz_localize(None) == ts.replace(tzinfo=None) - - @td.skip_if_windows - def test_replace_tzinfo(self): - # GH#15683 - dt = datetime(2016, 3, 27, 1) - tzinfo = pytz.timezone("CET").localize(dt, is_dst=False).tzinfo - - result_dt = dt.replace(tzinfo=tzinfo) - result_pd = Timestamp(dt).replace(tzinfo=tzinfo) - - # datetime.timestamp() converts in the local timezone - with tm.set_timezone("UTC"): - assert result_dt.timestamp() == result_pd.timestamp() - - assert result_dt == result_pd - assert result_dt == result_pd.to_pydatetime() - - result_dt = dt.replace(tzinfo=tzinfo).replace(tzinfo=None) - result_pd = Timestamp(dt).replace(tzinfo=tzinfo).replace(tzinfo=None) - - # datetime.timestamp() converts in the local timezone - with tm.set_timezone("UTC"): - assert result_dt.timestamp() == result_pd.timestamp() - - assert result_dt == result_pd - assert result_dt == result_pd.to_pydatetime() - - @pytest.mark.parametrize( - "tz, normalize", - [ - (pytz.timezone("US/Eastern"), lambda x: x.tzinfo.normalize(x)), - (gettz("US/Eastern"), lambda x: x), - ], - ) - def test_replace_across_dst(self, tz, normalize): - # GH#18319 check that 1) timezone is correctly normalized and - # 2) that hour is not incorrectly changed by this normalization - ts_naive = Timestamp("2017-12-03 16:03:30") - ts_aware = conversion.localize_pydatetime(ts_naive, tz) - - # Preliminary sanity-check - assert ts_aware == normalize(ts_aware) - - # Replace across DST boundary - ts2 = ts_aware.replace(month=6) - - # Check that `replace` preserves hour literal - assert (ts2.hour, ts2.minute) == (ts_aware.hour, ts_aware.minute) - - # Check that post-replace object is appropriately normalized - ts2b = normalize(ts2) - assert ts2 == ts2b - - @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s"]) - def test_replace_dst_border(self, unit): - # Gh 7825 - t = Timestamp("2013-11-3", tz="America/Chicago").as_unit(unit) - result = t.replace(hour=3) - expected = Timestamp("2013-11-3 03:00:00", tz="America/Chicago") - assert result == expected - assert result._creso == getattr(NpyDatetimeUnit, f"NPY_FR_{unit}").value - - @pytest.mark.parametrize("fold", [0, 1]) - @pytest.mark.parametrize("tz", ["dateutil/Europe/London", "Europe/London"]) - @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s"]) - def test_replace_dst_fold(self, fold, tz, unit): - # GH 25017 - d = datetime(2019, 10, 27, 2, 30) - ts = Timestamp(d, tz=tz).as_unit(unit) - result = ts.replace(hour=1, fold=fold) - expected = Timestamp(datetime(2019, 10, 27, 1, 30)).tz_localize( - tz, ambiguous=not fold - ) - assert result == expected - assert result._creso == getattr(NpyDatetimeUnit, f"NPY_FR_{unit}").value - - # -------------------------------------------------------------- - # Timestamp.normalize - - @pytest.mark.parametrize("arg", ["2013-11-30", "2013-11-30 12:00:00"]) - @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s"]) - def test_normalize(self, tz_naive_fixture, arg, unit): - tz = tz_naive_fixture - ts = Timestamp(arg, tz=tz).as_unit(unit) - result = ts.normalize() - expected = Timestamp("2013-11-30", tz=tz) - assert result == expected - assert result._creso == getattr(NpyDatetimeUnit, f"NPY_FR_{unit}").value - - def test_normalize_pre_epoch_dates(self): - # GH: 36294 - result = Timestamp("1969-01-01 09:00:00").normalize() - expected = Timestamp("1969-01-01 00:00:00") - assert result == expected - - # -------------------------------------------------------------- - - @td.skip_if_windows - def test_timestamp(self, fixed_now_ts): - # GH#17329 - # tz-naive --> treat it as if it were UTC for purposes of timestamp() - ts = fixed_now_ts - uts = ts.replace(tzinfo=utc) - assert ts.timestamp() == uts.timestamp() - - tsc = Timestamp("2014-10-11 11:00:01.12345678", tz="US/Central") - utsc = tsc.tz_convert("UTC") - - # utsc is a different representation of the same time - assert tsc.timestamp() == utsc.timestamp() - - # datetime.timestamp() converts in the local timezone - with tm.set_timezone("UTC"): - # should agree with datetime.timestamp method - dt = ts.to_pydatetime() - assert dt.timestamp() == ts.timestamp() - - -@pytest.mark.parametrize("fold", [0, 1]) -def test_replace_preserves_fold(fold): - # GH 37610. Check that replace preserves Timestamp fold property - tz = gettz("Europe/Moscow") - - ts = Timestamp(year=2009, month=10, day=25, hour=2, minute=30, fold=fold, tzinfo=tz) - ts_replaced = ts.replace(second=1) - - assert ts_replaced.fold == fold diff --git a/pandas/tests/scalar/timestamp/methods/test_timestamp_method.py b/pandas/tests/scalar/timestamp/methods/test_timestamp_method.py new file mode 100644 index 0000000000000..67985bd4ba566 --- /dev/null +++ b/pandas/tests/scalar/timestamp/methods/test_timestamp_method.py @@ -0,0 +1,31 @@ +# NB: This is for the Timestamp.timestamp *method* specifically, not +# the Timestamp class in general. + +from pytz import utc + +from pandas._libs.tslibs import Timestamp +import pandas.util._test_decorators as td + +import pandas._testing as tm + + +class TestTimestampMethod: + @td.skip_if_windows + def test_timestamp(self, fixed_now_ts): + # GH#17329 + # tz-naive --> treat it as if it were UTC for purposes of timestamp() + ts = fixed_now_ts + uts = ts.replace(tzinfo=utc) + assert ts.timestamp() == uts.timestamp() + + tsc = Timestamp("2014-10-11 11:00:01.12345678", tz="US/Central") + utsc = tsc.tz_convert("UTC") + + # utsc is a different representation of the same time + assert tsc.timestamp() == utsc.timestamp() + + # datetime.timestamp() converts in the local timezone + with tm.set_timezone("UTC"): + # should agree with datetime.timestamp method + dt = ts.to_pydatetime() + assert dt.timestamp() == ts.timestamp() diff --git a/pandas/tests/scalar/timestamp/methods/test_to_julian_date.py b/pandas/tests/scalar/timestamp/methods/test_to_julian_date.py new file mode 100644 index 0000000000000..7769614b601a4 --- /dev/null +++ b/pandas/tests/scalar/timestamp/methods/test_to_julian_date.py @@ -0,0 +1,28 @@ +from pandas import Timestamp + + +class TestTimestampToJulianDate: + def test_compare_1700(self): + ts = Timestamp("1700-06-23") + res = ts.to_julian_date() + assert res == 2_342_145.5 + + def test_compare_2000(self): + ts = Timestamp("2000-04-12") + res = ts.to_julian_date() + assert res == 2_451_646.5 + + def test_compare_2100(self): + ts = Timestamp("2100-08-12") + res = ts.to_julian_date() + assert res == 2_488_292.5 + + def test_compare_hour01(self): + ts = Timestamp("2000-08-12T01:00:00") + res = ts.to_julian_date() + assert res == 2_451_768.5416666666666666 + + def test_compare_hour13(self): + ts = Timestamp("2000-08-12T13:00:00") + res = ts.to_julian_date() + assert res == 2_451_769.0416666666666666 diff --git a/pandas/tests/scalar/timestamp/methods/test_to_pydatetime.py b/pandas/tests/scalar/timestamp/methods/test_to_pydatetime.py new file mode 100644 index 0000000000000..57f57e56201c8 --- /dev/null +++ b/pandas/tests/scalar/timestamp/methods/test_to_pydatetime.py @@ -0,0 +1,81 @@ +from datetime import ( + datetime, + timedelta, +) + +import pytz + +from pandas._libs.tslibs.timezones import dateutil_gettz as gettz +import pandas.util._test_decorators as td + +from pandas import Timestamp +import pandas._testing as tm + + +class TestTimestampToPyDatetime: + def test_to_pydatetime_fold(self): + # GH#45087 + tzstr = "dateutil/usr/share/zoneinfo/America/Chicago" + ts = Timestamp(year=2013, month=11, day=3, hour=1, minute=0, fold=1, tz=tzstr) + dt = ts.to_pydatetime() + assert dt.fold == 1 + + def test_to_pydatetime_nonzero_nano(self): + ts = Timestamp("2011-01-01 9:00:00.123456789") + + # Warn the user of data loss (nanoseconds). + with tm.assert_produces_warning(UserWarning): + expected = datetime(2011, 1, 1, 9, 0, 0, 123456) + result = ts.to_pydatetime() + assert result == expected + + def test_timestamp_to_datetime(self): + stamp = Timestamp("20090415", tz="US/Eastern") + dtval = stamp.to_pydatetime() + assert stamp == dtval + assert stamp.tzinfo == dtval.tzinfo + + def test_timestamp_to_pydatetime_dateutil(self): + stamp = Timestamp("20090415", tz="dateutil/US/Eastern") + dtval = stamp.to_pydatetime() + assert stamp == dtval + assert stamp.tzinfo == dtval.tzinfo + + def test_timestamp_to_pydatetime_explicit_pytz(self): + stamp = Timestamp("20090415", tz=pytz.timezone("US/Eastern")) + dtval = stamp.to_pydatetime() + assert stamp == dtval + assert stamp.tzinfo == dtval.tzinfo + + @td.skip_if_windows + def test_timestamp_to_pydatetime_explicit_dateutil(self): + stamp = Timestamp("20090415", tz=gettz("US/Eastern")) + dtval = stamp.to_pydatetime() + assert stamp == dtval + assert stamp.tzinfo == dtval.tzinfo + + def test_to_pydatetime_bijective(self): + # Ensure that converting to datetime and back only loses precision + # by going from nanoseconds to microseconds. + exp_warning = None if Timestamp.max.nanosecond == 0 else UserWarning + with tm.assert_produces_warning(exp_warning): + pydt_max = Timestamp.max.to_pydatetime() + + assert ( + Timestamp(pydt_max).as_unit("ns")._value / 1000 + == Timestamp.max._value / 1000 + ) + + exp_warning = None if Timestamp.min.nanosecond == 0 else UserWarning + with tm.assert_produces_warning(exp_warning): + pydt_min = Timestamp.min.to_pydatetime() + + # The next assertion can be enabled once GH#39221 is merged + # assert pydt_min < Timestamp.min # this is bc nanos are dropped + tdus = timedelta(microseconds=1) + assert pydt_min + tdus > Timestamp.min + + assert ( + Timestamp(pydt_min + tdus).as_unit("ns")._value / 1000 + == Timestamp.min._value / 1000 + ) diff --git a/pandas/tests/scalar/timestamp/methods/test_tz_convert.py b/pandas/tests/scalar/timestamp/methods/test_tz_convert.py new file mode 100644 index 0000000000000..02c85a8f325d5 --- /dev/null +++ b/pandas/tests/scalar/timestamp/methods/test_tz_convert.py @@ -0,0 +1,57 @@ +import dateutil +import pytest + +from pandas._libs.tslibs import timezones +import pandas.util._test_decorators as td + +from pandas import Timestamp + +try: + from zoneinfo import ZoneInfo +except ImportError: + # Cannot assign to a type + ZoneInfo = None # type: ignore[misc, assignment] + + +class TestTimestampTZConvert: + @pytest.mark.parametrize("tzstr", ["US/Eastern", "dateutil/US/Eastern"]) + def test_astimezone(self, tzstr): + # astimezone is an alias for tz_convert, so keep it with + # the tz_convert tests + utcdate = Timestamp("3/11/2012 22:00", tz="UTC") + expected = utcdate.tz_convert(tzstr) + result = utcdate.astimezone(tzstr) + assert expected == result + assert isinstance(result, Timestamp) + + @pytest.mark.parametrize( + "stamp", + [ + "2014-02-01 09:00", + "2014-07-08 09:00", + "2014-11-01 17:00", + "2014-11-05 00:00", + ], + ) + def test_tz_convert_roundtrip(self, stamp, tz_aware_fixture): + tz = tz_aware_fixture + + ts = Timestamp(stamp, tz="UTC") + converted = ts.tz_convert(tz) + + reset = converted.tz_convert(None) + assert reset == Timestamp(stamp) + assert reset.tzinfo is None + assert reset == converted.tz_convert("UTC").tz_localize(None) + + @td.skip_if_windows + def test_tz_convert_utc_with_system_utc(self): + # from system utc to real utc + ts = Timestamp("2001-01-05 11:56", tz=timezones.maybe_get_tz("dateutil/UTC")) + # check that the time hasn't changed. + assert ts == ts.tz_convert(dateutil.tz.tzutc()) + + # from system utc to real utc + ts = Timestamp("2001-01-05 11:56", tz=timezones.maybe_get_tz("dateutil/UTC")) + # check that the time hasn't changed. + assert ts == ts.tz_convert(dateutil.tz.tzutc()) diff --git a/pandas/tests/scalar/timestamp/methods/test_tz_localize.py b/pandas/tests/scalar/timestamp/methods/test_tz_localize.py new file mode 100644 index 0000000000000..247a583bc38f3 --- /dev/null +++ b/pandas/tests/scalar/timestamp/methods/test_tz_localize.py @@ -0,0 +1,312 @@ +from datetime import timedelta +import re + +from dateutil.tz import gettz +import pytest +import pytz +from pytz.exceptions import ( + AmbiguousTimeError, + NonExistentTimeError, +) + +from pandas._libs.tslibs.dtypes import NpyDatetimeUnit +from pandas.errors import OutOfBoundsDatetime + +from pandas import ( + NaT, + Timestamp, +) + +try: + from zoneinfo import ZoneInfo +except ImportError: + # Cannot assign to a type + ZoneInfo = None # type: ignore[misc, assignment] + + +class TestTimestampTZLocalize: + def test_tz_localize_pushes_out_of_bounds(self): + # GH#12677 + # tz_localize that pushes away from the boundary is OK + msg = ( + f"Converting {Timestamp.min.strftime('%Y-%m-%d %H:%M:%S')} " + f"underflows past {Timestamp.min}" + ) + pac = Timestamp.min.tz_localize("US/Pacific") + assert pac._value > Timestamp.min._value + pac.tz_convert("Asia/Tokyo") # tz_convert doesn't change value + with pytest.raises(OutOfBoundsDatetime, match=msg): + Timestamp.min.tz_localize("Asia/Tokyo") + + # tz_localize that pushes away from the boundary is OK + msg = ( + f"Converting {Timestamp.max.strftime('%Y-%m-%d %H:%M:%S')} " + f"overflows past {Timestamp.max}" + ) + tokyo = Timestamp.max.tz_localize("Asia/Tokyo") + assert tokyo._value < Timestamp.max._value + tokyo.tz_convert("US/Pacific") # tz_convert doesn't change value + with pytest.raises(OutOfBoundsDatetime, match=msg): + Timestamp.max.tz_localize("US/Pacific") + + @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s"]) + def test_tz_localize_ambiguous_bool(self, unit): + # make sure that we are correctly accepting bool values as ambiguous + # GH#14402 + ts = Timestamp("2015-11-01 01:00:03").as_unit(unit) + expected0 = Timestamp("2015-11-01 01:00:03-0500", tz="US/Central") + expected1 = Timestamp("2015-11-01 01:00:03-0600", tz="US/Central") + + msg = "Cannot infer dst time from 2015-11-01 01:00:03" + with pytest.raises(pytz.AmbiguousTimeError, match=msg): + ts.tz_localize("US/Central") + + with pytest.raises(pytz.AmbiguousTimeError, match=msg): + ts.tz_localize("dateutil/US/Central") + + if ZoneInfo is not None: + try: + tz = ZoneInfo("US/Central") + except KeyError: + # no tzdata + pass + else: + with pytest.raises(pytz.AmbiguousTimeError, match=msg): + ts.tz_localize(tz) + + result = ts.tz_localize("US/Central", ambiguous=True) + assert result == expected0 + assert result._creso == getattr(NpyDatetimeUnit, f"NPY_FR_{unit}").value + + result = ts.tz_localize("US/Central", ambiguous=False) + assert result == expected1 + assert result._creso == getattr(NpyDatetimeUnit, f"NPY_FR_{unit}").value + + def test_tz_localize_ambiguous(self): + ts = Timestamp("2014-11-02 01:00") + 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 + msg = re.escape( + "'ambiguous' parameter must be one of: " + "True, False, 'NaT', 'raise' (default)" + ) + with pytest.raises(ValueError, match=msg): + ts.tz_localize("US/Eastern", ambiguous="infer") + + # GH#8025 + msg = "Cannot localize tz-aware Timestamp, use tz_convert for conversions" + with pytest.raises(TypeError, match=msg): + Timestamp("2011-01-01", tz="US/Eastern").tz_localize("Asia/Tokyo") + + msg = "Cannot convert tz-naive Timestamp, use tz_localize to localize" + with pytest.raises(TypeError, match=msg): + Timestamp("2011-01-01").tz_convert("Asia/Tokyo") + + @pytest.mark.parametrize( + "stamp, tz", + [ + ("2015-03-08 02:00", "US/Eastern"), + ("2015-03-08 02:30", "US/Pacific"), + ("2015-03-29 02:00", "Europe/Paris"), + ("2015-03-29 02:30", "Europe/Belgrade"), + ], + ) + def test_tz_localize_nonexistent(self, stamp, tz): + # GH#13057 + ts = Timestamp(stamp) + with pytest.raises(NonExistentTimeError, match=stamp): + ts.tz_localize(tz) + # GH 22644 + with pytest.raises(NonExistentTimeError, match=stamp): + ts.tz_localize(tz, nonexistent="raise") + assert ts.tz_localize(tz, nonexistent="NaT") is NaT + + def test_tz_localize_ambiguous_raise(self): + # GH#13057 + ts = Timestamp("2015-11-1 01:00") + msg = "Cannot infer dst time from 2015-11-01 01:00:00," + with pytest.raises(AmbiguousTimeError, match=msg): + ts.tz_localize("US/Pacific", ambiguous="raise") + + def test_tz_localize_nonexistent_invalid_arg(self, warsaw): + # GH 22644 + tz = warsaw + ts = Timestamp("2015-03-29 02:00:00") + msg = ( + "The nonexistent argument must be one of 'raise', 'NaT', " + "'shift_forward', 'shift_backward' or a timedelta object" + ) + with pytest.raises(ValueError, match=msg): + ts.tz_localize(tz, nonexistent="foo") + + @pytest.mark.parametrize( + "stamp", + [ + "2014-02-01 09:00", + "2014-07-08 09:00", + "2014-11-01 17:00", + "2014-11-05 00:00", + ], + ) + def test_tz_localize_roundtrip(self, stamp, tz_aware_fixture): + tz = tz_aware_fixture + ts = Timestamp(stamp) + localized = ts.tz_localize(tz) + assert localized == Timestamp(stamp, tz=tz) + + msg = "Cannot localize tz-aware Timestamp" + with pytest.raises(TypeError, match=msg): + localized.tz_localize(tz) + + reset = localized.tz_localize(None) + assert reset == ts + assert reset.tzinfo is None + + def test_tz_localize_ambiguous_compat(self): + # validate that pytz and dateutil are compat for dst + # when the transition happens + naive = Timestamp("2013-10-27 01:00:00") + + pytz_zone = "Europe/London" + dateutil_zone = "dateutil/Europe/London" + 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 + + # fixed ambiguous behavior + # see gh-14621, GH#45087 + assert result_pytz.to_pydatetime().tzname() == "GMT" + assert result_dateutil.to_pydatetime().tzname() == "GMT" + assert str(result_pytz) == str(result_dateutil) + + # 1 hour difference + 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 + + # see gh-14621 + assert str(result_pytz) == str(result_dateutil) + assert ( + result_pytz.to_pydatetime().tzname() + == result_dateutil.to_pydatetime().tzname() + ) + + @pytest.mark.parametrize( + "tz", + [ + pytz.timezone("US/Eastern"), + gettz("US/Eastern"), + "US/Eastern", + "dateutil/US/Eastern", + ], + ) + def test_timestamp_tz_localize(self, tz): + stamp = Timestamp("3/11/2012 04:00") + + result = stamp.tz_localize(tz) + expected = Timestamp("3/11/2012 04:00", tz=tz) + assert result.hour == expected.hour + assert result == expected + + @pytest.mark.parametrize( + "start_ts, tz, end_ts, shift", + [ + ["2015-03-29 02:20:00", "Europe/Warsaw", "2015-03-29 03:00:00", "forward"], + [ + "2015-03-29 02:20:00", + "Europe/Warsaw", + "2015-03-29 01:59:59.999999999", + "backward", + ], + [ + "2015-03-29 02:20:00", + "Europe/Warsaw", + "2015-03-29 03:20:00", + timedelta(hours=1), + ], + [ + "2015-03-29 02:20:00", + "Europe/Warsaw", + "2015-03-29 01:20:00", + timedelta(hours=-1), + ], + ["2018-03-11 02:33:00", "US/Pacific", "2018-03-11 03:00:00", "forward"], + [ + "2018-03-11 02:33:00", + "US/Pacific", + "2018-03-11 01:59:59.999999999", + "backward", + ], + [ + "2018-03-11 02:33:00", + "US/Pacific", + "2018-03-11 03:33:00", + timedelta(hours=1), + ], + [ + "2018-03-11 02:33:00", + "US/Pacific", + "2018-03-11 01:33:00", + timedelta(hours=-1), + ], + ], + ) + @pytest.mark.parametrize("tz_type", ["", "dateutil/"]) + @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s"]) + def test_timestamp_tz_localize_nonexistent_shift( + self, start_ts, tz, end_ts, shift, tz_type, unit + ): + # GH 8917, 24466 + tz = tz_type + tz + if isinstance(shift, str): + shift = "shift_" + shift + ts = Timestamp(start_ts).as_unit(unit) + result = ts.tz_localize(tz, nonexistent=shift) + expected = Timestamp(end_ts).tz_localize(tz) + + if unit == "us": + assert result == expected.replace(nanosecond=0) + elif unit == "ms": + micros = expected.microsecond - expected.microsecond % 1000 + assert result == expected.replace(microsecond=micros, nanosecond=0) + elif unit == "s": + assert result == expected.replace(microsecond=0, nanosecond=0) + else: + assert result == expected + assert result._creso == getattr(NpyDatetimeUnit, f"NPY_FR_{unit}").value + + @pytest.mark.parametrize("offset", [-1, 1]) + def test_timestamp_tz_localize_nonexistent_shift_invalid(self, offset, warsaw): + # GH 8917, 24466 + tz = warsaw + ts = Timestamp("2015-03-29 02:20:00") + msg = "The provided timedelta will relocalize on a nonexistent time" + with pytest.raises(ValueError, match=msg): + ts.tz_localize(tz, nonexistent=timedelta(seconds=offset)) + + @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s"]) + def test_timestamp_tz_localize_nonexistent_NaT(self, warsaw, unit): + # GH 8917 + tz = warsaw + ts = Timestamp("2015-03-29 02:20:00").as_unit(unit) + result = ts.tz_localize(tz, nonexistent="NaT") + assert result is NaT + + @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s"]) + def test_timestamp_tz_localize_nonexistent_raise(self, warsaw, unit): + # GH 8917 + tz = warsaw + ts = Timestamp("2015-03-29 02:20:00").as_unit(unit) + msg = "2015-03-29 02:20:00" + with pytest.raises(pytz.NonExistentTimeError, match=msg): + ts.tz_localize(tz, nonexistent="raise") + msg = ( + "The nonexistent argument must be one of 'raise', 'NaT', " + "'shift_forward', 'shift_backward' or a timedelta object" + ) + with pytest.raises(ValueError, match=msg): + ts.tz_localize(tz, nonexistent="foo") diff --git a/pandas/tests/scalar/timestamp/test_arithmetic.py b/pandas/tests/scalar/timestamp/test_arithmetic.py index 9c24d364841d1..2d58513989a66 100644 --- a/pandas/tests/scalar/timestamp/test_arithmetic.py +++ b/pandas/tests/scalar/timestamp/test_arithmetic.py @@ -4,8 +4,10 @@ timezone, ) +from dateutil.tz import gettz import numpy as np import pytest +import pytz from pandas._libs.tslibs import ( OutOfBoundsDatetime, @@ -288,3 +290,45 @@ def test_subtract_different_utc_objects(self, utc_fixture, utc_fixture2): result = ts1 - ts2 expected = Timedelta(0) assert result == expected + + @pytest.mark.parametrize( + "tz", + [ + pytz.timezone("US/Eastern"), + gettz("US/Eastern"), + "US/Eastern", + "dateutil/US/Eastern", + ], + ) + def test_timestamp_add_timedelta_push_over_dst_boundary(self, tz): + # GH#1389 + + # 4 hours before DST transition + stamp = Timestamp("3/10/2012 22:00", tz=tz) + + result = stamp + timedelta(hours=6) + + # spring forward, + "7" hours + expected = Timestamp("3/11/2012 05:00", tz=tz) + + assert result == expected + + +class SubDatetime(datetime): + pass + + +@pytest.mark.parametrize( + "lh,rh", + [ + (SubDatetime(2000, 1, 1), Timedelta(hours=1)), + (Timedelta(hours=1), SubDatetime(2000, 1, 1)), + ], +) +def test_dt_subclass_add_timedelta(lh, rh): + # GH#25851 + # ensure that subclassed datetime works for + # Timedelta operations + result = lh + rh + expected = SubDatetime(2000, 1, 1, 1) + assert result == expected diff --git a/pandas/tests/scalar/timestamp/test_formats.py b/pandas/tests/scalar/timestamp/test_formats.py index 0c154963d3726..d7160597ea6d6 100644 --- a/pandas/tests/scalar/timestamp/test_formats.py +++ b/pandas/tests/scalar/timestamp/test_formats.py @@ -1,4 +1,9 @@ +from datetime import datetime +import pprint + +import dateutil.tz import pytest +import pytz # a test below uses pytz but only inside a `eval` call from pandas import Timestamp @@ -80,3 +85,117 @@ ) def test_isoformat(ts, timespec, expected_iso): assert ts.isoformat(timespec=timespec) == expected_iso + + +class TestTimestampRendering: + timezones = ["UTC", "Asia/Tokyo", "US/Eastern", "dateutil/US/Pacific"] + + @pytest.mark.parametrize("tz", timezones) + @pytest.mark.parametrize("freq", ["D", "M", "S", "N"]) + @pytest.mark.parametrize( + "date", ["2014-03-07", "2014-01-01 09:00", "2014-01-01 00:00:00.000000001"] + ) + def test_repr(self, date, freq, tz): + # avoid to match with timezone name + freq_repr = f"'{freq}'" + if tz.startswith("dateutil"): + tz_repr = tz.replace("dateutil", "") + else: + tz_repr = tz + + date_only = Timestamp(date) + assert date in repr(date_only) + assert tz_repr not in repr(date_only) + assert freq_repr not in repr(date_only) + assert date_only == eval(repr(date_only)) + + date_tz = Timestamp(date, tz=tz) + assert date in repr(date_tz) + assert tz_repr in repr(date_tz) + assert freq_repr not in repr(date_tz) + assert date_tz == eval(repr(date_tz)) + + def test_repr_utcoffset(self): + # This can cause the tz field to be populated, but it's redundant to + # include this information in the date-string. + date_with_utc_offset = Timestamp("2014-03-13 00:00:00-0400", tz=None) + assert "2014-03-13 00:00:00-0400" in repr(date_with_utc_offset) + assert "tzoffset" not in repr(date_with_utc_offset) + assert "UTC-04:00" in repr(date_with_utc_offset) + expr = repr(date_with_utc_offset) + assert date_with_utc_offset == eval(expr) + + def test_timestamp_repr_pre1900(self): + # pre-1900 + stamp = Timestamp("1850-01-01", tz="US/Eastern") + repr(stamp) + + iso8601 = "1850-01-01 01:23:45.012345" + stamp = Timestamp(iso8601, tz="US/Eastern") + result = repr(stamp) + assert iso8601 in result + + def test_pprint(self): + # GH#12622 + nested_obj = {"foo": 1, "bar": [{"w": {"a": Timestamp("2011-01-01")}}] * 10} + result = pprint.pformat(nested_obj, width=50) + expected = r"""{'bar': [{'w': {'a': Timestamp('2011-01-01 00:00:00')}}, + {'w': {'a': Timestamp('2011-01-01 00:00:00')}}, + {'w': {'a': Timestamp('2011-01-01 00:00:00')}}, + {'w': {'a': Timestamp('2011-01-01 00:00:00')}}, + {'w': {'a': Timestamp('2011-01-01 00:00:00')}}, + {'w': {'a': Timestamp('2011-01-01 00:00:00')}}, + {'w': {'a': Timestamp('2011-01-01 00:00:00')}}, + {'w': {'a': Timestamp('2011-01-01 00:00:00')}}, + {'w': {'a': Timestamp('2011-01-01 00:00:00')}}, + {'w': {'a': Timestamp('2011-01-01 00:00:00')}}], + 'foo': 1}""" + assert result == expected + + def test_to_timestamp_repr_is_code(self): + zs = [ + Timestamp("99-04-17 00:00:00", tz="UTC"), + Timestamp("2001-04-17 00:00:00", tz="UTC"), + Timestamp("2001-04-17 00:00:00", tz="America/Los_Angeles"), + Timestamp("2001-04-17 00:00:00", tz=None), + ] + for z in zs: + assert eval(repr(z)) == z + + def test_repr_matches_pydatetime_no_tz(self): + dt_date = datetime(2013, 1, 2) + assert str(dt_date) == str(Timestamp(dt_date)) + + dt_datetime = datetime(2013, 1, 2, 12, 1, 3) + assert str(dt_datetime) == str(Timestamp(dt_datetime)) + + dt_datetime_us = datetime(2013, 1, 2, 12, 1, 3, 45) + assert str(dt_datetime_us) == str(Timestamp(dt_datetime_us)) + + ts_nanos_only = Timestamp(200) + assert str(ts_nanos_only) == "1970-01-01 00:00:00.000000200" + + ts_nanos_micros = Timestamp(1200) + assert str(ts_nanos_micros) == "1970-01-01 00:00:00.000001200" + + def test_repr_matches_pydatetime_tz_pytz(self): + dt_date = datetime(2013, 1, 2, tzinfo=pytz.utc) + assert str(dt_date) == str(Timestamp(dt_date)) + + dt_datetime = datetime(2013, 1, 2, 12, 1, 3, tzinfo=pytz.utc) + assert str(dt_datetime) == str(Timestamp(dt_datetime)) + + dt_datetime_us = datetime(2013, 1, 2, 12, 1, 3, 45, tzinfo=pytz.utc) + assert str(dt_datetime_us) == str(Timestamp(dt_datetime_us)) + + def test_repr_matches_pydatetime_tz_dateutil(self): + utc = dateutil.tz.tzutc() + + dt_date = datetime(2013, 1, 2, tzinfo=utc) + assert str(dt_date) == str(Timestamp(dt_date)) + + dt_datetime = datetime(2013, 1, 2, 12, 1, 3, tzinfo=utc) + assert str(dt_datetime) == str(Timestamp(dt_datetime)) + + dt_datetime_us = datetime(2013, 1, 2, 12, 1, 3, 45, tzinfo=utc) + assert str(dt_datetime_us) == str(Timestamp(dt_datetime_us)) diff --git a/pandas/tests/scalar/timestamp/test_rendering.py b/pandas/tests/scalar/timestamp/test_rendering.py deleted file mode 100644 index ec1df2901d7db..0000000000000 --- a/pandas/tests/scalar/timestamp/test_rendering.py +++ /dev/null @@ -1,122 +0,0 @@ -from datetime import datetime -import pprint - -import dateutil.tz -import pytest -import pytz # a test below uses pytz but only inside a `eval` call - -from pandas import Timestamp - - -class TestTimestampRendering: - timezones = ["UTC", "Asia/Tokyo", "US/Eastern", "dateutil/US/Pacific"] - - @pytest.mark.parametrize("tz", timezones) - @pytest.mark.parametrize("freq", ["D", "M", "S", "N"]) - @pytest.mark.parametrize( - "date", ["2014-03-07", "2014-01-01 09:00", "2014-01-01 00:00:00.000000001"] - ) - def test_repr(self, date, freq, tz): - # avoid to match with timezone name - freq_repr = f"'{freq}'" - if tz.startswith("dateutil"): - tz_repr = tz.replace("dateutil", "") - else: - tz_repr = tz - - date_only = Timestamp(date) - assert date in repr(date_only) - assert tz_repr not in repr(date_only) - assert freq_repr not in repr(date_only) - assert date_only == eval(repr(date_only)) - - date_tz = Timestamp(date, tz=tz) - assert date in repr(date_tz) - assert tz_repr in repr(date_tz) - assert freq_repr not in repr(date_tz) - assert date_tz == eval(repr(date_tz)) - - def test_repr_utcoffset(self): - # This can cause the tz field to be populated, but it's redundant to - # include this information in the date-string. - date_with_utc_offset = Timestamp("2014-03-13 00:00:00-0400", tz=None) - assert "2014-03-13 00:00:00-0400" in repr(date_with_utc_offset) - assert "tzoffset" not in repr(date_with_utc_offset) - assert "UTC-04:00" in repr(date_with_utc_offset) - expr = repr(date_with_utc_offset) - assert date_with_utc_offset == eval(expr) - - def test_timestamp_repr_pre1900(self): - # pre-1900 - stamp = Timestamp("1850-01-01", tz="US/Eastern") - repr(stamp) - - iso8601 = "1850-01-01 01:23:45.012345" - stamp = Timestamp(iso8601, tz="US/Eastern") - result = repr(stamp) - assert iso8601 in result - - def test_pprint(self): - # GH#12622 - nested_obj = {"foo": 1, "bar": [{"w": {"a": Timestamp("2011-01-01")}}] * 10} - result = pprint.pformat(nested_obj, width=50) - expected = r"""{'bar': [{'w': {'a': Timestamp('2011-01-01 00:00:00')}}, - {'w': {'a': Timestamp('2011-01-01 00:00:00')}}, - {'w': {'a': Timestamp('2011-01-01 00:00:00')}}, - {'w': {'a': Timestamp('2011-01-01 00:00:00')}}, - {'w': {'a': Timestamp('2011-01-01 00:00:00')}}, - {'w': {'a': Timestamp('2011-01-01 00:00:00')}}, - {'w': {'a': Timestamp('2011-01-01 00:00:00')}}, - {'w': {'a': Timestamp('2011-01-01 00:00:00')}}, - {'w': {'a': Timestamp('2011-01-01 00:00:00')}}, - {'w': {'a': Timestamp('2011-01-01 00:00:00')}}], - 'foo': 1}""" - assert result == expected - - def test_to_timestamp_repr_is_code(self): - zs = [ - Timestamp("99-04-17 00:00:00", tz="UTC"), - Timestamp("2001-04-17 00:00:00", tz="UTC"), - Timestamp("2001-04-17 00:00:00", tz="America/Los_Angeles"), - Timestamp("2001-04-17 00:00:00", tz=None), - ] - for z in zs: - assert eval(repr(z)) == z - - def test_repr_matches_pydatetime_no_tz(self): - dt_date = datetime(2013, 1, 2) - assert str(dt_date) == str(Timestamp(dt_date)) - - dt_datetime = datetime(2013, 1, 2, 12, 1, 3) - assert str(dt_datetime) == str(Timestamp(dt_datetime)) - - dt_datetime_us = datetime(2013, 1, 2, 12, 1, 3, 45) - assert str(dt_datetime_us) == str(Timestamp(dt_datetime_us)) - - ts_nanos_only = Timestamp(200) - assert str(ts_nanos_only) == "1970-01-01 00:00:00.000000200" - - ts_nanos_micros = Timestamp(1200) - assert str(ts_nanos_micros) == "1970-01-01 00:00:00.000001200" - - def test_repr_matches_pydatetime_tz_pytz(self): - dt_date = datetime(2013, 1, 2, tzinfo=pytz.utc) - assert str(dt_date) == str(Timestamp(dt_date)) - - dt_datetime = datetime(2013, 1, 2, 12, 1, 3, tzinfo=pytz.utc) - assert str(dt_datetime) == str(Timestamp(dt_datetime)) - - dt_datetime_us = datetime(2013, 1, 2, 12, 1, 3, 45, tzinfo=pytz.utc) - assert str(dt_datetime_us) == str(Timestamp(dt_datetime_us)) - - def test_repr_matches_pydatetime_tz_dateutil(self): - utc = dateutil.tz.tzutc() - - dt_date = datetime(2013, 1, 2, tzinfo=utc) - assert str(dt_date) == str(Timestamp(dt_date)) - - dt_datetime = datetime(2013, 1, 2, 12, 1, 3, tzinfo=utc) - assert str(dt_datetime) == str(Timestamp(dt_datetime)) - - dt_datetime_us = datetime(2013, 1, 2, 12, 1, 3, 45, tzinfo=utc) - assert str(dt_datetime_us) == str(Timestamp(dt_datetime_us)) diff --git a/pandas/tests/scalar/timestamp/test_timestamp.py b/pandas/tests/scalar/timestamp/test_timestamp.py index ded32a77cbaf7..b23efbaf721d9 100644 --- a/pandas/tests/scalar/timestamp/test_timestamp.py +++ b/pandas/tests/scalar/timestamp/test_timestamp.py @@ -31,8 +31,6 @@ tz_compare, ) from pandas.compat import IS64 -from pandas.errors import OutOfBoundsDatetime -import pandas.util._test_decorators as td from pandas import ( NaT, @@ -299,12 +297,13 @@ def test_asm8(self): assert Timestamp("nat").asm8.view("i8") == np.datetime64("nat", "ns").view("i8") - def test_class_ops_pytz(self): + def test_class_ops(self): def compare(x, y): assert int((Timestamp(x)._value - Timestamp(y)._value) / 1e9) == 0 compare(Timestamp.now(), datetime.now()) compare(Timestamp.now("UTC"), datetime.now(pytz.timezone("UTC"))) + compare(Timestamp.now("UTC"), datetime.now(tzutc())) compare(Timestamp.utcnow(), datetime.now(timezone.utc)) compare(Timestamp.today(), datetime.today()) current_time = calendar.timegm(datetime.now().utctimetuple()) @@ -332,36 +331,6 @@ def compare(x, y): datetime.combine(date_component, time_component), ) - def test_class_ops_dateutil(self): - def compare(x, y): - assert ( - int( - np.round(Timestamp(x)._value / 1e9) - - np.round(Timestamp(y)._value / 1e9) - ) - == 0 - ) - - compare(Timestamp.now(), datetime.now()) - compare(Timestamp.now("UTC"), datetime.now(tzutc())) - compare(Timestamp.utcnow(), datetime.now(timezone.utc)) - compare(Timestamp.today(), datetime.today()) - current_time = calendar.timegm(datetime.now().utctimetuple()) - - ts_utc = Timestamp.utcfromtimestamp(current_time) - assert ts_utc.timestamp() == current_time - - compare( - Timestamp.fromtimestamp(current_time), datetime.fromtimestamp(current_time) - ) - - date_component = datetime.now(timezone.utc) - time_component = (date_component + timedelta(minutes=10)).time() - compare( - Timestamp.combine(date_component, time_component), - datetime.combine(date_component, time_component), - ) - def test_basics_nanos(self): val = np.int64(946_684_800_000_000_000).view("M8[ns]") stamp = Timestamp(val.view("i8") + 500) @@ -545,28 +514,6 @@ def test_nanosecond_timestamp(self): assert t.nanosecond == 10 -class TestTimestampToJulianDate: - def test_compare_1700(self): - r = Timestamp("1700-06-23").to_julian_date() - assert r == 2_342_145.5 - - def test_compare_2000(self): - r = Timestamp("2000-04-12").to_julian_date() - assert r == 2_451_646.5 - - def test_compare_2100(self): - r = Timestamp("2100-08-12").to_julian_date() - assert r == 2_488_292.5 - - def test_compare_hour01(self): - r = Timestamp("2000-08-12T01:00:00").to_julian_date() - assert r == 2_451_768.5416666666666666 - - def test_compare_hour13(self): - r = Timestamp("2000-08-12T13:00:00").to_julian_date() - assert r == 2_451_769.0416666666666666 - - class TestTimestampConversion: def test_conversion(self): # GH#9255 @@ -583,73 +530,6 @@ def test_conversion(self): assert type(result) == type(expected) assert result.dtype == expected.dtype - def test_to_pydatetime_fold(self): - # GH#45087 - tzstr = "dateutil/usr/share/zoneinfo/America/Chicago" - ts = Timestamp(year=2013, month=11, day=3, hour=1, minute=0, fold=1, tz=tzstr) - dt = ts.to_pydatetime() - assert dt.fold == 1 - - def test_to_pydatetime_nonzero_nano(self): - ts = Timestamp("2011-01-01 9:00:00.123456789") - - # Warn the user of data loss (nanoseconds). - with tm.assert_produces_warning(UserWarning): - expected = datetime(2011, 1, 1, 9, 0, 0, 123456) - result = ts.to_pydatetime() - assert result == expected - - def test_timestamp_to_datetime(self): - stamp = Timestamp("20090415", tz="US/Eastern") - dtval = stamp.to_pydatetime() - assert stamp == dtval - assert stamp.tzinfo == dtval.tzinfo - - def test_timestamp_to_datetime_dateutil(self): - stamp = Timestamp("20090415", tz="dateutil/US/Eastern") - dtval = stamp.to_pydatetime() - assert stamp == dtval - assert stamp.tzinfo == dtval.tzinfo - - def test_timestamp_to_datetime_explicit_pytz(self): - stamp = Timestamp("20090415", tz=pytz.timezone("US/Eastern")) - dtval = stamp.to_pydatetime() - assert stamp == dtval - assert stamp.tzinfo == dtval.tzinfo - - @td.skip_if_windows - def test_timestamp_to_datetime_explicit_dateutil(self): - stamp = Timestamp("20090415", tz=gettz("US/Eastern")) - dtval = stamp.to_pydatetime() - assert stamp == dtval - assert stamp.tzinfo == dtval.tzinfo - - def test_to_datetime_bijective(self): - # Ensure that converting to datetime and back only loses precision - # by going from nanoseconds to microseconds. - exp_warning = None if Timestamp.max.nanosecond == 0 else UserWarning - with tm.assert_produces_warning(exp_warning): - pydt_max = Timestamp.max.to_pydatetime() - - assert ( - Timestamp(pydt_max).as_unit("ns")._value / 1000 - == Timestamp.max._value / 1000 - ) - - exp_warning = None if Timestamp.min.nanosecond == 0 else UserWarning - with tm.assert_produces_warning(exp_warning): - pydt_min = Timestamp.min.to_pydatetime() - - # The next assertion can be enabled once GH#39221 is merged - # assert pydt_min < Timestamp.min # this is bc nanos are dropped - tdus = timedelta(microseconds=1) - assert pydt_min + tdus > Timestamp.min - - assert ( - Timestamp(pydt_min + tdus).as_unit("ns")._value / 1000 - == Timestamp.min._value / 1000 - ) - def test_to_period_tz_warning(self): # GH#21333 make sure a warning is issued when timezone # info is lost @@ -671,26 +551,6 @@ def test_to_numpy_alias(self): ts.to_numpy(copy=True) -class SubDatetime(datetime): - pass - - -@pytest.mark.parametrize( - "lh,rh", - [ - (SubDatetime(2000, 1, 1), Timedelta(hours=1)), - (Timedelta(hours=1), SubDatetime(2000, 1, 1)), - ], -) -def test_dt_subclass_add_timedelta(lh, rh): - # GH#25851 - # ensure that subclassed datetime works for - # Timedelta operations - result = lh + rh - expected = SubDatetime(2000, 1, 1, 1) - assert result == expected - - class TestNonNano: @pytest.fixture(params=["s", "ms", "us"]) def reso(self, request): @@ -1060,86 +920,6 @@ def test_timestamp_class_min_max_resolution(): assert Timestamp.resolution._creso == NpyDatetimeUnit.NPY_FR_ns.value -class TestAsUnit: - def test_as_unit(self): - ts = Timestamp("1970-01-01").as_unit("ns") - assert ts.unit == "ns" - - assert ts.as_unit("ns") is ts - - res = ts.as_unit("us") - assert res._value == ts._value // 1000 - assert res._creso == NpyDatetimeUnit.NPY_FR_us.value - - rt = res.as_unit("ns") - assert rt._value == ts._value - assert rt._creso == ts._creso - - res = ts.as_unit("ms") - assert res._value == ts._value // 1_000_000 - assert res._creso == NpyDatetimeUnit.NPY_FR_ms.value - - rt = res.as_unit("ns") - assert rt._value == ts._value - assert rt._creso == ts._creso - - res = ts.as_unit("s") - assert res._value == ts._value // 1_000_000_000 - assert res._creso == NpyDatetimeUnit.NPY_FR_s.value - - rt = res.as_unit("ns") - assert rt._value == ts._value - assert rt._creso == ts._creso - - def test_as_unit_overflows(self): - # microsecond that would be just out of bounds for nano - us = 9223372800000000 - ts = Timestamp._from_value_and_reso(us, NpyDatetimeUnit.NPY_FR_us.value, None) - - msg = "Cannot cast 2262-04-12 00:00:00 to unit='ns' without overflow" - with pytest.raises(OutOfBoundsDatetime, match=msg): - ts.as_unit("ns") - - res = ts.as_unit("ms") - assert res._value == us // 1000 - assert res._creso == NpyDatetimeUnit.NPY_FR_ms.value - - def test_as_unit_rounding(self): - ts = Timestamp(1_500_000) # i.e. 1500 microseconds - res = ts.as_unit("ms") - - expected = Timestamp(1_000_000) # i.e. 1 millisecond - assert res == expected - - assert res._creso == NpyDatetimeUnit.NPY_FR_ms.value - assert res._value == 1 - - with pytest.raises(ValueError, match="Cannot losslessly convert units"): - ts.as_unit("ms", round_ok=False) - - def test_as_unit_non_nano(self): - # case where we are going neither to nor from nano - ts = Timestamp("1970-01-02").as_unit("ms") - assert ts.year == 1970 - assert ts.month == 1 - assert ts.day == 2 - assert ts.hour == ts.minute == ts.second == ts.microsecond == ts.nanosecond == 0 - - res = ts.as_unit("s") - assert res._value == 24 * 3600 - assert res.year == 1970 - assert res.month == 1 - assert res.day == 2 - assert ( - res.hour - == res.minute - == res.second - == res.microsecond - == res.nanosecond - == 0 - ) - - def test_delimited_date(): # https://github.com/pandas-dev/pandas/issues/50231 with tm.assert_produces_warning(None): diff --git a/pandas/tests/scalar/timestamp/test_timezones.py b/pandas/tests/scalar/timestamp/test_timezones.py index 3a6953af4337e..ea6b72de33aeb 100644 --- a/pandas/tests/scalar/timestamp/test_timezones.py +++ b/pandas/tests/scalar/timestamp/test_timezones.py @@ -4,32 +4,19 @@ from datetime import ( date, datetime, - timedelta, timezone, ) -import re -import dateutil from dateutil.tz import ( gettz, tzoffset, ) import pytest import pytz -from pytz.exceptions import ( - AmbiguousTimeError, - NonExistentTimeError, -) from pandas._libs.tslibs import timezones -from pandas._libs.tslibs.dtypes import NpyDatetimeUnit -from pandas.errors import OutOfBoundsDatetime -import pandas.util._test_decorators as td -from pandas import ( - NaT, - Timestamp, -) +from pandas import Timestamp try: from zoneinfo import ZoneInfo @@ -39,340 +26,6 @@ class TestTimestampTZOperations: - # -------------------------------------------------------------- - # Timestamp.tz_localize - - def test_tz_localize_pushes_out_of_bounds(self): - # GH#12677 - # tz_localize that pushes away from the boundary is OK - msg = ( - f"Converting {Timestamp.min.strftime('%Y-%m-%d %H:%M:%S')} " - f"underflows past {Timestamp.min}" - ) - pac = Timestamp.min.tz_localize("US/Pacific") - assert pac._value > Timestamp.min._value - pac.tz_convert("Asia/Tokyo") # tz_convert doesn't change value - with pytest.raises(OutOfBoundsDatetime, match=msg): - Timestamp.min.tz_localize("Asia/Tokyo") - - # tz_localize that pushes away from the boundary is OK - msg = ( - f"Converting {Timestamp.max.strftime('%Y-%m-%d %H:%M:%S')} " - f"overflows past {Timestamp.max}" - ) - tokyo = Timestamp.max.tz_localize("Asia/Tokyo") - assert tokyo._value < Timestamp.max._value - tokyo.tz_convert("US/Pacific") # tz_convert doesn't change value - with pytest.raises(OutOfBoundsDatetime, match=msg): - Timestamp.max.tz_localize("US/Pacific") - - @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s"]) - def test_tz_localize_ambiguous_bool(self, unit): - # make sure that we are correctly accepting bool values as ambiguous - # GH#14402 - ts = Timestamp("2015-11-01 01:00:03").as_unit(unit) - expected0 = Timestamp("2015-11-01 01:00:03-0500", tz="US/Central") - expected1 = Timestamp("2015-11-01 01:00:03-0600", tz="US/Central") - - msg = "Cannot infer dst time from 2015-11-01 01:00:03" - with pytest.raises(pytz.AmbiguousTimeError, match=msg): - ts.tz_localize("US/Central") - - with pytest.raises(pytz.AmbiguousTimeError, match=msg): - ts.tz_localize("dateutil/US/Central") - - if ZoneInfo is not None: - try: - tz = ZoneInfo("US/Central") - except KeyError: - # no tzdata - pass - else: - with pytest.raises(pytz.AmbiguousTimeError, match=msg): - ts.tz_localize(tz) - - result = ts.tz_localize("US/Central", ambiguous=True) - assert result == expected0 - assert result._creso == getattr(NpyDatetimeUnit, f"NPY_FR_{unit}").value - - result = ts.tz_localize("US/Central", ambiguous=False) - assert result == expected1 - assert result._creso == getattr(NpyDatetimeUnit, f"NPY_FR_{unit}").value - - def test_tz_localize_ambiguous(self): - ts = Timestamp("2014-11-02 01:00") - 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 - msg = re.escape( - "'ambiguous' parameter must be one of: " - "True, False, 'NaT', 'raise' (default)" - ) - with pytest.raises(ValueError, match=msg): - ts.tz_localize("US/Eastern", ambiguous="infer") - - # GH#8025 - msg = "Cannot localize tz-aware Timestamp, use tz_convert for conversions" - with pytest.raises(TypeError, match=msg): - Timestamp("2011-01-01", tz="US/Eastern").tz_localize("Asia/Tokyo") - - msg = "Cannot convert tz-naive Timestamp, use tz_localize to localize" - with pytest.raises(TypeError, match=msg): - Timestamp("2011-01-01").tz_convert("Asia/Tokyo") - - @pytest.mark.parametrize( - "stamp, tz", - [ - ("2015-03-08 02:00", "US/Eastern"), - ("2015-03-08 02:30", "US/Pacific"), - ("2015-03-29 02:00", "Europe/Paris"), - ("2015-03-29 02:30", "Europe/Belgrade"), - ], - ) - def test_tz_localize_nonexistent(self, stamp, tz): - # GH#13057 - ts = Timestamp(stamp) - with pytest.raises(NonExistentTimeError, match=stamp): - ts.tz_localize(tz) - # GH 22644 - with pytest.raises(NonExistentTimeError, match=stamp): - ts.tz_localize(tz, nonexistent="raise") - assert ts.tz_localize(tz, nonexistent="NaT") is NaT - - def test_tz_localize_ambiguous_raise(self): - # GH#13057 - ts = Timestamp("2015-11-1 01:00") - msg = "Cannot infer dst time from 2015-11-01 01:00:00," - with pytest.raises(AmbiguousTimeError, match=msg): - ts.tz_localize("US/Pacific", ambiguous="raise") - - def test_tz_localize_nonexistent_invalid_arg(self, warsaw): - # GH 22644 - tz = warsaw - ts = Timestamp("2015-03-29 02:00:00") - msg = ( - "The nonexistent argument must be one of 'raise', 'NaT', " - "'shift_forward', 'shift_backward' or a timedelta object" - ) - with pytest.raises(ValueError, match=msg): - ts.tz_localize(tz, nonexistent="foo") - - @pytest.mark.parametrize( - "stamp", - [ - "2014-02-01 09:00", - "2014-07-08 09:00", - "2014-11-01 17:00", - "2014-11-05 00:00", - ], - ) - def test_tz_localize_roundtrip(self, stamp, tz_aware_fixture): - tz = tz_aware_fixture - ts = Timestamp(stamp) - localized = ts.tz_localize(tz) - assert localized == Timestamp(stamp, tz=tz) - - msg = "Cannot localize tz-aware Timestamp" - with pytest.raises(TypeError, match=msg): - localized.tz_localize(tz) - - reset = localized.tz_localize(None) - assert reset == ts - assert reset.tzinfo is None - - def test_tz_localize_ambiguous_compat(self): - # validate that pytz and dateutil are compat for dst - # when the transition happens - naive = Timestamp("2013-10-27 01:00:00") - - pytz_zone = "Europe/London" - dateutil_zone = "dateutil/Europe/London" - 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 - - # fixed ambiguous behavior - # see gh-14621, GH#45087 - assert result_pytz.to_pydatetime().tzname() == "GMT" - assert result_dateutil.to_pydatetime().tzname() == "GMT" - assert str(result_pytz) == str(result_dateutil) - - # 1 hour difference - 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 - - # see gh-14621 - assert str(result_pytz) == str(result_dateutil) - assert ( - result_pytz.to_pydatetime().tzname() - == result_dateutil.to_pydatetime().tzname() - ) - - @pytest.mark.parametrize( - "tz", - [ - pytz.timezone("US/Eastern"), - gettz("US/Eastern"), - "US/Eastern", - "dateutil/US/Eastern", - ], - ) - def test_timestamp_tz_localize(self, tz): - stamp = Timestamp("3/11/2012 04:00") - - result = stamp.tz_localize(tz) - expected = Timestamp("3/11/2012 04:00", tz=tz) - assert result.hour == expected.hour - assert result == expected - - @pytest.mark.parametrize( - "start_ts, tz, end_ts, shift", - [ - ["2015-03-29 02:20:00", "Europe/Warsaw", "2015-03-29 03:00:00", "forward"], - [ - "2015-03-29 02:20:00", - "Europe/Warsaw", - "2015-03-29 01:59:59.999999999", - "backward", - ], - [ - "2015-03-29 02:20:00", - "Europe/Warsaw", - "2015-03-29 03:20:00", - timedelta(hours=1), - ], - [ - "2015-03-29 02:20:00", - "Europe/Warsaw", - "2015-03-29 01:20:00", - timedelta(hours=-1), - ], - ["2018-03-11 02:33:00", "US/Pacific", "2018-03-11 03:00:00", "forward"], - [ - "2018-03-11 02:33:00", - "US/Pacific", - "2018-03-11 01:59:59.999999999", - "backward", - ], - [ - "2018-03-11 02:33:00", - "US/Pacific", - "2018-03-11 03:33:00", - timedelta(hours=1), - ], - [ - "2018-03-11 02:33:00", - "US/Pacific", - "2018-03-11 01:33:00", - timedelta(hours=-1), - ], - ], - ) - @pytest.mark.parametrize("tz_type", ["", "dateutil/"]) - @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s"]) - def test_timestamp_tz_localize_nonexistent_shift( - self, start_ts, tz, end_ts, shift, tz_type, unit - ): - # GH 8917, 24466 - tz = tz_type + tz - if isinstance(shift, str): - shift = "shift_" + shift - ts = Timestamp(start_ts).as_unit(unit) - result = ts.tz_localize(tz, nonexistent=shift) - expected = Timestamp(end_ts).tz_localize(tz) - - if unit == "us": - assert result == expected.replace(nanosecond=0) - elif unit == "ms": - micros = expected.microsecond - expected.microsecond % 1000 - assert result == expected.replace(microsecond=micros, nanosecond=0) - elif unit == "s": - assert result == expected.replace(microsecond=0, nanosecond=0) - else: - assert result == expected - assert result._creso == getattr(NpyDatetimeUnit, f"NPY_FR_{unit}").value - - @pytest.mark.parametrize("offset", [-1, 1]) - def test_timestamp_tz_localize_nonexistent_shift_invalid(self, offset, warsaw): - # GH 8917, 24466 - tz = warsaw - ts = Timestamp("2015-03-29 02:20:00") - msg = "The provided timedelta will relocalize on a nonexistent time" - with pytest.raises(ValueError, match=msg): - ts.tz_localize(tz, nonexistent=timedelta(seconds=offset)) - - @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s"]) - def test_timestamp_tz_localize_nonexistent_NaT(self, warsaw, unit): - # GH 8917 - tz = warsaw - ts = Timestamp("2015-03-29 02:20:00").as_unit(unit) - result = ts.tz_localize(tz, nonexistent="NaT") - assert result is NaT - - @pytest.mark.parametrize("unit", ["ns", "us", "ms", "s"]) - def test_timestamp_tz_localize_nonexistent_raise(self, warsaw, unit): - # GH 8917 - tz = warsaw - ts = Timestamp("2015-03-29 02:20:00").as_unit(unit) - msg = "2015-03-29 02:20:00" - with pytest.raises(pytz.NonExistentTimeError, match=msg): - ts.tz_localize(tz, nonexistent="raise") - msg = ( - "The nonexistent argument must be one of 'raise', 'NaT', " - "'shift_forward', 'shift_backward' or a timedelta object" - ) - with pytest.raises(ValueError, match=msg): - ts.tz_localize(tz, nonexistent="foo") - - # ------------------------------------------------------------------ - # Timestamp.tz_convert - - @pytest.mark.parametrize( - "stamp", - [ - "2014-02-01 09:00", - "2014-07-08 09:00", - "2014-11-01 17:00", - "2014-11-05 00:00", - ], - ) - def test_tz_convert_roundtrip(self, stamp, tz_aware_fixture): - tz = tz_aware_fixture - - ts = Timestamp(stamp, tz="UTC") - converted = ts.tz_convert(tz) - - reset = converted.tz_convert(None) - assert reset == Timestamp(stamp) - assert reset.tzinfo is None - assert reset == converted.tz_convert("UTC").tz_localize(None) - - @pytest.mark.parametrize("tzstr", ["US/Eastern", "dateutil/US/Eastern"]) - def test_astimezone(self, tzstr): - # astimezone is an alias for tz_convert, so keep it with - # the tz_convert tests - utcdate = Timestamp("3/11/2012 22:00", tz="UTC") - expected = utcdate.tz_convert(tzstr) - result = utcdate.astimezone(tzstr) - assert expected == result - assert isinstance(result, Timestamp) - - @td.skip_if_windows - def test_tz_convert_utc_with_system_utc(self): - # from system utc to real utc - ts = Timestamp("2001-01-05 11:56", tz=timezones.maybe_get_tz("dateutil/UTC")) - # check that the time hasn't changed. - assert ts == ts.tz_convert(dateutil.tz.tzutc()) - - # from system utc to real utc - ts = Timestamp("2001-01-05 11:56", tz=timezones.maybe_get_tz("dateutil/UTC")) - # check that the time hasn't changed. - assert ts == ts.tz_convert(dateutil.tz.tzutc()) - # ------------------------------------------------------------------ # Timestamp.__init__ with tz str or tzinfo @@ -459,28 +112,6 @@ def test_timestamp_constructed_by_date_and_tz(self, tz): assert result.hour == expected.hour assert result == expected - @pytest.mark.parametrize( - "tz", - [ - pytz.timezone("US/Eastern"), - gettz("US/Eastern"), - "US/Eastern", - "dateutil/US/Eastern", - ], - ) - def test_timestamp_add_timedelta_push_over_dst_boundary(self, tz): - # GH#1389 - - # 4 hours before DST transition - stamp = Timestamp("3/10/2012 22:00", tz=tz) - - result = stamp + timedelta(hours=6) - - # spring forward, + "7" hours - expected = Timestamp("3/11/2012 05:00", tz=tz) - - assert result == expected - def test_timestamp_timetz_equivalent_with_datetime_tz(self, tz_naive_fixture): # GH21358 tz = timezones.maybe_get_tz(tz_naive_fixture) From ec860a8fea08eef4f6232ea560ba2fa6062de332 Mon Sep 17 00:00:00 2001 From: Brock Date: Tue, 24 Oct 2023 17:56:22 -0700 Subject: [PATCH 2/2] mypy fixup --- pandas/tests/scalar/timestamp/methods/__init__.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 pandas/tests/scalar/timestamp/methods/__init__.py diff --git a/pandas/tests/scalar/timestamp/methods/__init__.py b/pandas/tests/scalar/timestamp/methods/__init__.py new file mode 100644 index 0000000000000..e69de29bb2d1d