virtuelle Umgebung teil20b
This commit is contained in:
		
										
											Binary file not shown.
										
									
								
							
										
											Binary file not shown.
										
									
								
							
										
											Binary file not shown.
										
									
								
							
										
											Binary file not shown.
										
									
								
							
										
											Binary file not shown.
										
									
								
							
										
											
												File diff suppressed because it is too large
												Load Diff
											
										
									
								
							@@ -0,0 +1,532 @@
 | 
			
		||||
from datetime import timedelta
 | 
			
		||||
from itertools import product
 | 
			
		||||
 | 
			
		||||
import numpy as np
 | 
			
		||||
import pytest
 | 
			
		||||
 | 
			
		||||
from pandas._libs.tslibs import OutOfBoundsTimedelta
 | 
			
		||||
from pandas._libs.tslibs.dtypes import NpyDatetimeUnit
 | 
			
		||||
 | 
			
		||||
from pandas import (
 | 
			
		||||
    NaT,
 | 
			
		||||
    Timedelta,
 | 
			
		||||
    offsets,
 | 
			
		||||
    to_timedelta,
 | 
			
		||||
)
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
def test_construct_with_weeks_unit_overflow():
 | 
			
		||||
    # GH#47268 don't silently wrap around
 | 
			
		||||
    with pytest.raises(OutOfBoundsTimedelta, match="without overflow"):
 | 
			
		||||
        Timedelta(1000000000000000000, unit="W")
 | 
			
		||||
 | 
			
		||||
    with pytest.raises(OutOfBoundsTimedelta, match="without overflow"):
 | 
			
		||||
        Timedelta(1000000000000000000.0, unit="W")
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
def test_construct_from_td64_with_unit():
 | 
			
		||||
    # ignore the unit, as it may cause silently overflows leading to incorrect
 | 
			
		||||
    #  results, and in non-overflow cases is irrelevant GH#46827
 | 
			
		||||
    obj = np.timedelta64(123456789000000000, "h")
 | 
			
		||||
 | 
			
		||||
    with pytest.raises(OutOfBoundsTimedelta, match="123456789000000000 hours"):
 | 
			
		||||
        Timedelta(obj, unit="ps")
 | 
			
		||||
 | 
			
		||||
    with pytest.raises(OutOfBoundsTimedelta, match="123456789000000000 hours"):
 | 
			
		||||
        Timedelta(obj, unit="ns")
 | 
			
		||||
 | 
			
		||||
    with pytest.raises(OutOfBoundsTimedelta, match="123456789000000000 hours"):
 | 
			
		||||
        Timedelta(obj)
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
def test_from_td64_retain_resolution():
 | 
			
		||||
    # case where we retain millisecond resolution
 | 
			
		||||
    obj = np.timedelta64(12345, "ms")
 | 
			
		||||
 | 
			
		||||
    td = Timedelta(obj)
 | 
			
		||||
    assert td._value == obj.view("i8")
 | 
			
		||||
    assert td._creso == NpyDatetimeUnit.NPY_FR_ms.value
 | 
			
		||||
 | 
			
		||||
    # Case where we cast to nearest-supported reso
 | 
			
		||||
    obj2 = np.timedelta64(1234, "D")
 | 
			
		||||
    td2 = Timedelta(obj2)
 | 
			
		||||
    assert td2._creso == NpyDatetimeUnit.NPY_FR_s.value
 | 
			
		||||
    assert td2 == obj2
 | 
			
		||||
    assert td2.days == 1234
 | 
			
		||||
 | 
			
		||||
    # Case that _would_ overflow if we didn't support non-nano
 | 
			
		||||
    obj3 = np.timedelta64(1000000000000000000, "us")
 | 
			
		||||
    td3 = Timedelta(obj3)
 | 
			
		||||
    assert td3.total_seconds() == 1000000000000
 | 
			
		||||
    assert td3._creso == NpyDatetimeUnit.NPY_FR_us.value
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
def test_from_pytimedelta_us_reso():
 | 
			
		||||
    # pytimedelta has microsecond resolution, so Timedelta(pytd) inherits that
 | 
			
		||||
    td = timedelta(days=4, minutes=3)
 | 
			
		||||
    result = Timedelta(td)
 | 
			
		||||
    assert result.to_pytimedelta() == td
 | 
			
		||||
    assert result._creso == NpyDatetimeUnit.NPY_FR_us.value
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
def test_from_tick_reso():
 | 
			
		||||
    tick = offsets.Nano()
 | 
			
		||||
    assert Timedelta(tick)._creso == NpyDatetimeUnit.NPY_FR_ns.value
 | 
			
		||||
 | 
			
		||||
    tick = offsets.Micro()
 | 
			
		||||
    assert Timedelta(tick)._creso == NpyDatetimeUnit.NPY_FR_us.value
 | 
			
		||||
 | 
			
		||||
    tick = offsets.Milli()
 | 
			
		||||
    assert Timedelta(tick)._creso == NpyDatetimeUnit.NPY_FR_ms.value
 | 
			
		||||
 | 
			
		||||
    tick = offsets.Second()
 | 
			
		||||
    assert Timedelta(tick)._creso == NpyDatetimeUnit.NPY_FR_s.value
 | 
			
		||||
 | 
			
		||||
    # everything above Second gets cast to the closest supported reso: second
 | 
			
		||||
    tick = offsets.Minute()
 | 
			
		||||
    assert Timedelta(tick)._creso == NpyDatetimeUnit.NPY_FR_s.value
 | 
			
		||||
 | 
			
		||||
    tick = offsets.Hour()
 | 
			
		||||
    assert Timedelta(tick)._creso == NpyDatetimeUnit.NPY_FR_s.value
 | 
			
		||||
 | 
			
		||||
    tick = offsets.Day()
 | 
			
		||||
    assert Timedelta(tick)._creso == NpyDatetimeUnit.NPY_FR_s.value
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
def test_construction():
 | 
			
		||||
    expected = np.timedelta64(10, "D").astype("m8[ns]").view("i8")
 | 
			
		||||
    assert Timedelta(10, unit="d")._value == expected
 | 
			
		||||
    assert Timedelta(10.0, unit="d")._value == expected
 | 
			
		||||
    assert Timedelta("10 days")._value == expected
 | 
			
		||||
    assert Timedelta(days=10)._value == expected
 | 
			
		||||
    assert Timedelta(days=10.0)._value == expected
 | 
			
		||||
 | 
			
		||||
    expected += np.timedelta64(10, "s").astype("m8[ns]").view("i8")
 | 
			
		||||
    assert Timedelta("10 days 00:00:10")._value == expected
 | 
			
		||||
    assert Timedelta(days=10, seconds=10)._value == expected
 | 
			
		||||
    assert Timedelta(days=10, milliseconds=10 * 1000)._value == expected
 | 
			
		||||
    assert Timedelta(days=10, microseconds=10 * 1000 * 1000)._value == expected
 | 
			
		||||
 | 
			
		||||
    # rounding cases
 | 
			
		||||
    assert Timedelta(82739999850000)._value == 82739999850000
 | 
			
		||||
    assert "0 days 22:58:59.999850" in str(Timedelta(82739999850000))
 | 
			
		||||
    assert Timedelta(123072001000000)._value == 123072001000000
 | 
			
		||||
    assert "1 days 10:11:12.001" in str(Timedelta(123072001000000))
 | 
			
		||||
 | 
			
		||||
    # string conversion with/without leading zero
 | 
			
		||||
    # GH#9570
 | 
			
		||||
    assert Timedelta("0:00:00") == timedelta(hours=0)
 | 
			
		||||
    assert Timedelta("00:00:00") == timedelta(hours=0)
 | 
			
		||||
    assert Timedelta("-1:00:00") == -timedelta(hours=1)
 | 
			
		||||
    assert Timedelta("-01:00:00") == -timedelta(hours=1)
 | 
			
		||||
 | 
			
		||||
    # more strings & abbrevs
 | 
			
		||||
    # GH#8190
 | 
			
		||||
    assert Timedelta("1 h") == timedelta(hours=1)
 | 
			
		||||
    assert Timedelta("1 hour") == timedelta(hours=1)
 | 
			
		||||
    assert Timedelta("1 hr") == timedelta(hours=1)
 | 
			
		||||
    assert Timedelta("1 hours") == timedelta(hours=1)
 | 
			
		||||
    assert Timedelta("-1 hours") == -timedelta(hours=1)
 | 
			
		||||
    assert Timedelta("1 m") == timedelta(minutes=1)
 | 
			
		||||
    assert Timedelta("1.5 m") == timedelta(seconds=90)
 | 
			
		||||
    assert Timedelta("1 minute") == timedelta(minutes=1)
 | 
			
		||||
    assert Timedelta("1 minutes") == timedelta(minutes=1)
 | 
			
		||||
    assert Timedelta("1 s") == timedelta(seconds=1)
 | 
			
		||||
    assert Timedelta("1 second") == timedelta(seconds=1)
 | 
			
		||||
    assert Timedelta("1 seconds") == timedelta(seconds=1)
 | 
			
		||||
    assert Timedelta("1 ms") == timedelta(milliseconds=1)
 | 
			
		||||
    assert Timedelta("1 milli") == timedelta(milliseconds=1)
 | 
			
		||||
    assert Timedelta("1 millisecond") == timedelta(milliseconds=1)
 | 
			
		||||
    assert Timedelta("1 us") == timedelta(microseconds=1)
 | 
			
		||||
    assert Timedelta("1 µs") == timedelta(microseconds=1)
 | 
			
		||||
    assert Timedelta("1 micros") == timedelta(microseconds=1)
 | 
			
		||||
    assert Timedelta("1 microsecond") == timedelta(microseconds=1)
 | 
			
		||||
    assert Timedelta("1.5 microsecond") == Timedelta("00:00:00.000001500")
 | 
			
		||||
    assert Timedelta("1 ns") == Timedelta("00:00:00.000000001")
 | 
			
		||||
    assert Timedelta("1 nano") == Timedelta("00:00:00.000000001")
 | 
			
		||||
    assert Timedelta("1 nanosecond") == Timedelta("00:00:00.000000001")
 | 
			
		||||
 | 
			
		||||
    # combos
 | 
			
		||||
    assert Timedelta("10 days 1 hour") == timedelta(days=10, hours=1)
 | 
			
		||||
    assert Timedelta("10 days 1 h") == timedelta(days=10, hours=1)
 | 
			
		||||
    assert Timedelta("10 days 1 h 1m 1s") == timedelta(
 | 
			
		||||
        days=10, hours=1, minutes=1, seconds=1
 | 
			
		||||
    )
 | 
			
		||||
    assert Timedelta("-10 days 1 h 1m 1s") == -timedelta(
 | 
			
		||||
        days=10, hours=1, minutes=1, seconds=1
 | 
			
		||||
    )
 | 
			
		||||
    assert Timedelta("-10 days 1 h 1m 1s") == -timedelta(
 | 
			
		||||
        days=10, hours=1, minutes=1, seconds=1
 | 
			
		||||
    )
 | 
			
		||||
    assert Timedelta("-10 days 1 h 1m 1s 3us") == -timedelta(
 | 
			
		||||
        days=10, hours=1, minutes=1, seconds=1, microseconds=3
 | 
			
		||||
    )
 | 
			
		||||
    assert Timedelta("-10 days 1 h 1.5m 1s 3us") == -timedelta(
 | 
			
		||||
        days=10, hours=1, minutes=1, seconds=31, microseconds=3
 | 
			
		||||
    )
 | 
			
		||||
 | 
			
		||||
    # Currently invalid as it has a - on the hh:mm:dd part
 | 
			
		||||
    # (only allowed on the days)
 | 
			
		||||
    msg = "only leading negative signs are allowed"
 | 
			
		||||
    with pytest.raises(ValueError, match=msg):
 | 
			
		||||
        Timedelta("-10 days -1 h 1.5m 1s 3us")
 | 
			
		||||
 | 
			
		||||
    # only leading neg signs are allowed
 | 
			
		||||
    with pytest.raises(ValueError, match=msg):
 | 
			
		||||
        Timedelta("10 days -1 h 1.5m 1s 3us")
 | 
			
		||||
 | 
			
		||||
    # no units specified
 | 
			
		||||
    msg = "no units specified"
 | 
			
		||||
    with pytest.raises(ValueError, match=msg):
 | 
			
		||||
        Timedelta("3.1415")
 | 
			
		||||
 | 
			
		||||
    # invalid construction
 | 
			
		||||
    msg = "cannot construct a Timedelta"
 | 
			
		||||
    with pytest.raises(ValueError, match=msg):
 | 
			
		||||
        Timedelta()
 | 
			
		||||
 | 
			
		||||
    msg = "unit abbreviation w/o a number"
 | 
			
		||||
    with pytest.raises(ValueError, match=msg):
 | 
			
		||||
        Timedelta("foo")
 | 
			
		||||
 | 
			
		||||
    msg = (
 | 
			
		||||
        "cannot construct a Timedelta from "
 | 
			
		||||
        "the passed arguments, allowed keywords are "
 | 
			
		||||
    )
 | 
			
		||||
    with pytest.raises(ValueError, match=msg):
 | 
			
		||||
        Timedelta(day=10)
 | 
			
		||||
 | 
			
		||||
    # floats
 | 
			
		||||
    expected = np.timedelta64(10, "s").astype("m8[ns]").view("i8") + np.timedelta64(
 | 
			
		||||
        500, "ms"
 | 
			
		||||
    ).astype("m8[ns]").view("i8")
 | 
			
		||||
    assert Timedelta(10.5, unit="s")._value == expected
 | 
			
		||||
 | 
			
		||||
    # offset
 | 
			
		||||
    assert to_timedelta(offsets.Hour(2)) == Timedelta(hours=2)
 | 
			
		||||
    assert Timedelta(offsets.Hour(2)) == Timedelta(hours=2)
 | 
			
		||||
    assert Timedelta(offsets.Second(2)) == Timedelta(seconds=2)
 | 
			
		||||
 | 
			
		||||
    # GH#11995: unicode
 | 
			
		||||
    expected = Timedelta("1H")
 | 
			
		||||
    result = Timedelta("1H")
 | 
			
		||||
    assert result == expected
 | 
			
		||||
    assert to_timedelta(offsets.Hour(2)) == Timedelta("0 days, 02:00:00")
 | 
			
		||||
 | 
			
		||||
    msg = "unit abbreviation w/o a number"
 | 
			
		||||
    with pytest.raises(ValueError, match=msg):
 | 
			
		||||
        Timedelta("foo bar")
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
@pytest.mark.parametrize(
 | 
			
		||||
    "item",
 | 
			
		||||
    list(
 | 
			
		||||
        {
 | 
			
		||||
            "days": "D",
 | 
			
		||||
            "seconds": "s",
 | 
			
		||||
            "microseconds": "us",
 | 
			
		||||
            "milliseconds": "ms",
 | 
			
		||||
            "minutes": "m",
 | 
			
		||||
            "hours": "h",
 | 
			
		||||
            "weeks": "W",
 | 
			
		||||
        }.items()
 | 
			
		||||
    ),
 | 
			
		||||
)
 | 
			
		||||
@pytest.mark.parametrize(
 | 
			
		||||
    "npdtype", [np.int64, np.int32, np.int16, np.float64, np.float32, np.float16]
 | 
			
		||||
)
 | 
			
		||||
def test_td_construction_with_np_dtypes(npdtype, item):
 | 
			
		||||
    # GH#8757: test construction with np dtypes
 | 
			
		||||
    pykwarg, npkwarg = item
 | 
			
		||||
    expected = np.timedelta64(1, npkwarg).astype("m8[ns]").view("i8")
 | 
			
		||||
    assert Timedelta(**{pykwarg: npdtype(1)})._value == expected
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
@pytest.mark.parametrize(
 | 
			
		||||
    "val",
 | 
			
		||||
    [
 | 
			
		||||
        "1s",
 | 
			
		||||
        "-1s",
 | 
			
		||||
        "1us",
 | 
			
		||||
        "-1us",
 | 
			
		||||
        "1 day",
 | 
			
		||||
        "-1 day",
 | 
			
		||||
        "-23:59:59.999999",
 | 
			
		||||
        "-1 days +23:59:59.999999",
 | 
			
		||||
        "-1ns",
 | 
			
		||||
        "1ns",
 | 
			
		||||
        "-23:59:59.999999999",
 | 
			
		||||
    ],
 | 
			
		||||
)
 | 
			
		||||
def test_td_from_repr_roundtrip(val):
 | 
			
		||||
    # round-trip both for string and value
 | 
			
		||||
    td = Timedelta(val)
 | 
			
		||||
    assert Timedelta(td._value) == td
 | 
			
		||||
 | 
			
		||||
    assert Timedelta(str(td)) == td
 | 
			
		||||
    assert Timedelta(td._repr_base(format="all")) == td
 | 
			
		||||
    assert Timedelta(td._repr_base()) == td
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
def test_overflow_on_construction():
 | 
			
		||||
    # GH#3374
 | 
			
		||||
    value = Timedelta("1day")._value * 20169940
 | 
			
		||||
    msg = "Cannot cast 1742682816000000000000 from ns to 'ns' without overflow"
 | 
			
		||||
    with pytest.raises(OutOfBoundsTimedelta, match=msg):
 | 
			
		||||
        Timedelta(value)
 | 
			
		||||
 | 
			
		||||
    # xref GH#17637
 | 
			
		||||
    msg = "Cannot cast 139993 from D to 'ns' without overflow"
 | 
			
		||||
    with pytest.raises(OutOfBoundsTimedelta, match=msg):
 | 
			
		||||
        Timedelta(7 * 19999, unit="D")
 | 
			
		||||
 | 
			
		||||
    # used to overflow before non-ns support
 | 
			
		||||
    td = Timedelta(timedelta(days=13 * 19999))
 | 
			
		||||
    assert td._creso == NpyDatetimeUnit.NPY_FR_us.value
 | 
			
		||||
    assert td.days == 13 * 19999
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
@pytest.mark.parametrize(
 | 
			
		||||
    "val, unit",
 | 
			
		||||
    [
 | 
			
		||||
        (15251, "W"),  # 1
 | 
			
		||||
        (106752, "D"),  # change from previous:
 | 
			
		||||
        (2562048, "h"),  # 0 hours
 | 
			
		||||
        (153722868, "m"),  # 13 minutes
 | 
			
		||||
        (9223372037, "s"),  # 44 seconds
 | 
			
		||||
    ],
 | 
			
		||||
)
 | 
			
		||||
def test_construction_out_of_bounds_td64ns(val, unit):
 | 
			
		||||
    # TODO: parametrize over units just above/below the implementation bounds
 | 
			
		||||
    #  once GH#38964 is resolved
 | 
			
		||||
 | 
			
		||||
    # Timedelta.max is just under 106752 days
 | 
			
		||||
    td64 = np.timedelta64(val, unit)
 | 
			
		||||
    assert td64.astype("m8[ns]").view("i8") < 0  # i.e. naive astype will be wrong
 | 
			
		||||
 | 
			
		||||
    td = Timedelta(td64)
 | 
			
		||||
    if unit != "M":
 | 
			
		||||
        # with unit="M" the conversion to "s" is poorly defined
 | 
			
		||||
        #  (and numpy issues DeprecationWarning)
 | 
			
		||||
        assert td.asm8 == td64
 | 
			
		||||
    assert td.asm8.dtype == "m8[s]"
 | 
			
		||||
    msg = r"Cannot cast 1067\d\d days .* to unit='ns' without overflow"
 | 
			
		||||
    with pytest.raises(OutOfBoundsTimedelta, match=msg):
 | 
			
		||||
        td.as_unit("ns")
 | 
			
		||||
 | 
			
		||||
    # But just back in bounds and we are OK
 | 
			
		||||
    assert Timedelta(td64 - 1) == td64 - 1
 | 
			
		||||
 | 
			
		||||
    td64 *= -1
 | 
			
		||||
    assert td64.astype("m8[ns]").view("i8") > 0  # i.e. naive astype will be wrong
 | 
			
		||||
 | 
			
		||||
    td2 = Timedelta(td64)
 | 
			
		||||
    msg = r"Cannot cast -1067\d\d days .* to unit='ns' without overflow"
 | 
			
		||||
    with pytest.raises(OutOfBoundsTimedelta, match=msg):
 | 
			
		||||
        td2.as_unit("ns")
 | 
			
		||||
 | 
			
		||||
    # But just back in bounds and we are OK
 | 
			
		||||
    assert Timedelta(td64 + 1) == td64 + 1
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
@pytest.mark.parametrize(
 | 
			
		||||
    "val, unit",
 | 
			
		||||
    [
 | 
			
		||||
        (15251 * 10**9, "W"),
 | 
			
		||||
        (106752 * 10**9, "D"),
 | 
			
		||||
        (2562048 * 10**9, "h"),
 | 
			
		||||
        (153722868 * 10**9, "m"),
 | 
			
		||||
    ],
 | 
			
		||||
)
 | 
			
		||||
def test_construction_out_of_bounds_td64s(val, unit):
 | 
			
		||||
    td64 = np.timedelta64(val, unit)
 | 
			
		||||
    with pytest.raises(OutOfBoundsTimedelta, match=str(td64)):
 | 
			
		||||
        Timedelta(td64)
 | 
			
		||||
 | 
			
		||||
    # But just back in bounds and we are OK
 | 
			
		||||
    assert Timedelta(td64 - 10**9) == td64 - 10**9
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
@pytest.mark.parametrize(
 | 
			
		||||
    "fmt,exp",
 | 
			
		||||
    [
 | 
			
		||||
        (
 | 
			
		||||
            "P6DT0H50M3.010010012S",
 | 
			
		||||
            Timedelta(
 | 
			
		||||
                days=6,
 | 
			
		||||
                minutes=50,
 | 
			
		||||
                seconds=3,
 | 
			
		||||
                milliseconds=10,
 | 
			
		||||
                microseconds=10,
 | 
			
		||||
                nanoseconds=12,
 | 
			
		||||
            ),
 | 
			
		||||
        ),
 | 
			
		||||
        (
 | 
			
		||||
            "P-6DT0H50M3.010010012S",
 | 
			
		||||
            Timedelta(
 | 
			
		||||
                days=-6,
 | 
			
		||||
                minutes=50,
 | 
			
		||||
                seconds=3,
 | 
			
		||||
                milliseconds=10,
 | 
			
		||||
                microseconds=10,
 | 
			
		||||
                nanoseconds=12,
 | 
			
		||||
            ),
 | 
			
		||||
        ),
 | 
			
		||||
        ("P4DT12H30M5S", Timedelta(days=4, hours=12, minutes=30, seconds=5)),
 | 
			
		||||
        ("P0DT0H0M0.000000123S", Timedelta(nanoseconds=123)),
 | 
			
		||||
        ("P0DT0H0M0.00001S", Timedelta(microseconds=10)),
 | 
			
		||||
        ("P0DT0H0M0.001S", Timedelta(milliseconds=1)),
 | 
			
		||||
        ("P0DT0H1M0S", Timedelta(minutes=1)),
 | 
			
		||||
        ("P1DT25H61M61S", Timedelta(days=1, hours=25, minutes=61, seconds=61)),
 | 
			
		||||
        ("PT1S", Timedelta(seconds=1)),
 | 
			
		||||
        ("PT0S", Timedelta(seconds=0)),
 | 
			
		||||
        ("P1WT0S", Timedelta(days=7, seconds=0)),
 | 
			
		||||
        ("P1D", Timedelta(days=1)),
 | 
			
		||||
        ("P1DT1H", Timedelta(days=1, hours=1)),
 | 
			
		||||
        ("P1W", Timedelta(days=7)),
 | 
			
		||||
        ("PT300S", Timedelta(seconds=300)),
 | 
			
		||||
        ("P1DT0H0M00000000000S", Timedelta(days=1)),
 | 
			
		||||
        ("PT-6H3M", Timedelta(hours=-6, minutes=3)),
 | 
			
		||||
        ("-PT6H3M", Timedelta(hours=-6, minutes=-3)),
 | 
			
		||||
        ("-PT-6H+3M", Timedelta(hours=6, minutes=-3)),
 | 
			
		||||
    ],
 | 
			
		||||
)
 | 
			
		||||
def test_iso_constructor(fmt, exp):
 | 
			
		||||
    assert Timedelta(fmt) == exp
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
@pytest.mark.parametrize(
 | 
			
		||||
    "fmt",
 | 
			
		||||
    [
 | 
			
		||||
        "PPPPPPPPPPPP",
 | 
			
		||||
        "PDTHMS",
 | 
			
		||||
        "P0DT999H999M999S",
 | 
			
		||||
        "P1DT0H0M0.0000000000000S",
 | 
			
		||||
        "P1DT0H0M0.S",
 | 
			
		||||
        "P",
 | 
			
		||||
        "-P",
 | 
			
		||||
    ],
 | 
			
		||||
)
 | 
			
		||||
def test_iso_constructor_raises(fmt):
 | 
			
		||||
    msg = f"Invalid ISO 8601 Duration format - {fmt}"
 | 
			
		||||
    with pytest.raises(ValueError, match=msg):
 | 
			
		||||
        Timedelta(fmt)
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
@pytest.mark.parametrize(
 | 
			
		||||
    "constructed_td, conversion",
 | 
			
		||||
    [
 | 
			
		||||
        (Timedelta(nanoseconds=100), "100ns"),
 | 
			
		||||
        (
 | 
			
		||||
            Timedelta(
 | 
			
		||||
                days=1,
 | 
			
		||||
                hours=1,
 | 
			
		||||
                minutes=1,
 | 
			
		||||
                weeks=1,
 | 
			
		||||
                seconds=1,
 | 
			
		||||
                milliseconds=1,
 | 
			
		||||
                microseconds=1,
 | 
			
		||||
                nanoseconds=1,
 | 
			
		||||
            ),
 | 
			
		||||
            694861001001001,
 | 
			
		||||
        ),
 | 
			
		||||
        (Timedelta(microseconds=1) + Timedelta(nanoseconds=1), "1us1ns"),
 | 
			
		||||
        (Timedelta(microseconds=1) - Timedelta(nanoseconds=1), "999ns"),
 | 
			
		||||
        (Timedelta(microseconds=1) + 5 * Timedelta(nanoseconds=-2), "990ns"),
 | 
			
		||||
    ],
 | 
			
		||||
)
 | 
			
		||||
def test_td_constructor_on_nanoseconds(constructed_td, conversion):
 | 
			
		||||
    # GH#9273
 | 
			
		||||
    assert constructed_td == Timedelta(conversion)
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
def test_td_constructor_value_error():
 | 
			
		||||
    msg = "Invalid type <class 'str'>. Must be int or float."
 | 
			
		||||
    with pytest.raises(TypeError, match=msg):
 | 
			
		||||
        Timedelta(nanoseconds="abc")
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
def test_timedelta_constructor_identity():
 | 
			
		||||
    # Test for #30543
 | 
			
		||||
    expected = Timedelta(np.timedelta64(1, "s"))
 | 
			
		||||
    result = Timedelta(expected)
 | 
			
		||||
    assert result is expected
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
def test_timedelta_pass_td_and_kwargs_raises():
 | 
			
		||||
    # don't silently ignore the kwargs GH#48898
 | 
			
		||||
    td = Timedelta(days=1)
 | 
			
		||||
    msg = (
 | 
			
		||||
        "Cannot pass both a Timedelta input and timedelta keyword arguments, "
 | 
			
		||||
        r"got \['days'\]"
 | 
			
		||||
    )
 | 
			
		||||
    with pytest.raises(ValueError, match=msg):
 | 
			
		||||
        Timedelta(td, days=2)
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
@pytest.mark.parametrize(
 | 
			
		||||
    "constructor, value, unit, expectation",
 | 
			
		||||
    [
 | 
			
		||||
        (Timedelta, "10s", "ms", (ValueError, "unit must not be specified")),
 | 
			
		||||
        (to_timedelta, "10s", "ms", (ValueError, "unit must not be specified")),
 | 
			
		||||
        (to_timedelta, ["1", 2, 3], "s", (ValueError, "unit must not be specified")),
 | 
			
		||||
    ],
 | 
			
		||||
)
 | 
			
		||||
def test_string_with_unit(constructor, value, unit, expectation):
 | 
			
		||||
    exp, match = expectation
 | 
			
		||||
    with pytest.raises(exp, match=match):
 | 
			
		||||
        _ = constructor(value, unit=unit)
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
@pytest.mark.parametrize(
 | 
			
		||||
    "value",
 | 
			
		||||
    [
 | 
			
		||||
        "".join(elements)
 | 
			
		||||
        for repetition in (1, 2)
 | 
			
		||||
        for elements in product("+-, ", repeat=repetition)
 | 
			
		||||
    ],
 | 
			
		||||
)
 | 
			
		||||
def test_string_without_numbers(value):
 | 
			
		||||
    # GH39710 Timedelta input string with only symbols and no digits raises an error
 | 
			
		||||
    msg = (
 | 
			
		||||
        "symbols w/o a number"
 | 
			
		||||
        if value != "--"
 | 
			
		||||
        else "only leading negative signs are allowed"
 | 
			
		||||
    )
 | 
			
		||||
    with pytest.raises(ValueError, match=msg):
 | 
			
		||||
        Timedelta(value)
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
def test_timedelta_new_npnat():
 | 
			
		||||
    # GH#48898
 | 
			
		||||
    nat = np.timedelta64("NaT", "h")
 | 
			
		||||
    assert Timedelta(nat) is NaT
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
def test_subclass_respected():
 | 
			
		||||
    # GH#49579
 | 
			
		||||
    class MyCustomTimedelta(Timedelta):
 | 
			
		||||
        pass
 | 
			
		||||
 | 
			
		||||
    td = MyCustomTimedelta("1 minute")
 | 
			
		||||
    assert isinstance(td, MyCustomTimedelta)
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
def test_non_nano_value():
 | 
			
		||||
    # https://github.com/pandas-dev/pandas/issues/49076
 | 
			
		||||
    result = Timedelta(10, unit="D").as_unit("s").value
 | 
			
		||||
    # `.value` shows nanoseconds, even though unit is 's'
 | 
			
		||||
    assert result == 864000000000000
 | 
			
		||||
 | 
			
		||||
    # out-of-nanoseconds-bounds `.value` raises informative message
 | 
			
		||||
    msg = (
 | 
			
		||||
        r"Cannot convert Timedelta to nanoseconds without overflow. "
 | 
			
		||||
        r"Use `.asm8.view\('i8'\)` to cast represent Timedelta in its "
 | 
			
		||||
        r"own unit \(here, s\).$"
 | 
			
		||||
    )
 | 
			
		||||
    td = Timedelta(1_000, "D").as_unit("s") * 1_000
 | 
			
		||||
    with pytest.raises(OverflowError, match=msg):
 | 
			
		||||
        td.value
 | 
			
		||||
    # check that the suggested workaround actually works
 | 
			
		||||
    result = td.asm8.view("i8")
 | 
			
		||||
    assert result == 86400000000
 | 
			
		||||
@@ -0,0 +1,44 @@
 | 
			
		||||
import pytest
 | 
			
		||||
 | 
			
		||||
from pandas import Timedelta
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
@pytest.mark.parametrize(
 | 
			
		||||
    "td, expected_repr",
 | 
			
		||||
    [
 | 
			
		||||
        (Timedelta(10, unit="d"), "Timedelta('10 days 00:00:00')"),
 | 
			
		||||
        (Timedelta(10, unit="s"), "Timedelta('0 days 00:00:10')"),
 | 
			
		||||
        (Timedelta(10, unit="ms"), "Timedelta('0 days 00:00:00.010000')"),
 | 
			
		||||
        (Timedelta(-10, unit="ms"), "Timedelta('-1 days +23:59:59.990000')"),
 | 
			
		||||
    ],
 | 
			
		||||
)
 | 
			
		||||
def test_repr(td, expected_repr):
 | 
			
		||||
    assert repr(td) == expected_repr
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
@pytest.mark.parametrize(
 | 
			
		||||
    "td, expected_iso",
 | 
			
		||||
    [
 | 
			
		||||
        (
 | 
			
		||||
            Timedelta(
 | 
			
		||||
                days=6,
 | 
			
		||||
                minutes=50,
 | 
			
		||||
                seconds=3,
 | 
			
		||||
                milliseconds=10,
 | 
			
		||||
                microseconds=10,
 | 
			
		||||
                nanoseconds=12,
 | 
			
		||||
            ),
 | 
			
		||||
            "P6DT0H50M3.010010012S",
 | 
			
		||||
        ),
 | 
			
		||||
        (Timedelta(days=4, hours=12, minutes=30, seconds=5), "P4DT12H30M5S"),
 | 
			
		||||
        (Timedelta(nanoseconds=123), "P0DT0H0M0.000000123S"),
 | 
			
		||||
        # trim nano
 | 
			
		||||
        (Timedelta(microseconds=10), "P0DT0H0M0.00001S"),
 | 
			
		||||
        # trim micro
 | 
			
		||||
        (Timedelta(milliseconds=1), "P0DT0H0M0.001S"),
 | 
			
		||||
        # don't strip every 0
 | 
			
		||||
        (Timedelta(minutes=1), "P0DT0H1M0S"),
 | 
			
		||||
    ],
 | 
			
		||||
)
 | 
			
		||||
def test_isoformat(td, expected_iso):
 | 
			
		||||
    assert td.isoformat() == expected_iso
 | 
			
		||||
										
											
												File diff suppressed because it is too large
												Load Diff
											
										
									
								
							
		Reference in New Issue
	
	Block a user