pruned venvs
This commit is contained in:
d3m1g0d
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
-76
@@ -1,76 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
from datetime import datetime, timedelta
|
||||
|
||||
import pytest
|
||||
import numpy as np
|
||||
|
||||
from pandas.compat import long
|
||||
from pandas.tseries import offsets
|
||||
from pandas import Timestamp, Timedelta
|
||||
|
||||
|
||||
class TestTimestampArithmetic(object):
|
||||
def test_overflow_offset(self):
|
||||
# xref https://github.com/statsmodels/statsmodels/issues/3374
|
||||
# ends up multiplying really large numbers which overflow
|
||||
|
||||
stamp = Timestamp('2017-01-13 00:00:00', freq='D')
|
||||
offset = 20169940 * offsets.Day(1)
|
||||
|
||||
with pytest.raises(OverflowError):
|
||||
stamp + offset
|
||||
|
||||
with pytest.raises(OverflowError):
|
||||
offset + stamp
|
||||
|
||||
with pytest.raises(OverflowError):
|
||||
stamp - offset
|
||||
|
||||
def test_delta_preserve_nanos(self):
|
||||
val = Timestamp(long(1337299200000000123))
|
||||
result = val + timedelta(1)
|
||||
assert result.nanosecond == val.nanosecond
|
||||
|
||||
def test_timestamp_sub_datetime(self):
|
||||
dt = datetime(2013, 10, 12)
|
||||
ts = Timestamp(datetime(2013, 10, 13))
|
||||
assert (ts - dt).days == 1
|
||||
assert (dt - ts).days == -1
|
||||
|
||||
def test_addition_subtraction_types(self):
|
||||
# Assert on the types resulting from Timestamp +/- various date/time
|
||||
# objects
|
||||
dt = datetime(2014, 3, 4)
|
||||
td = timedelta(seconds=1)
|
||||
# build a timestamp with a frequency, since then it supports
|
||||
# addition/subtraction of integers
|
||||
ts = Timestamp(dt, freq='D')
|
||||
|
||||
assert type(ts + 1) == Timestamp
|
||||
assert type(ts - 1) == Timestamp
|
||||
|
||||
# Timestamp + datetime not supported, though subtraction is supported
|
||||
# and yields timedelta more tests in tseries/base/tests/test_base.py
|
||||
assert type(ts - dt) == Timedelta
|
||||
assert type(ts + td) == Timestamp
|
||||
assert type(ts - td) == Timestamp
|
||||
|
||||
# Timestamp +/- datetime64 not supported, so not tested (could possibly
|
||||
# assert error raised?)
|
||||
td64 = np.timedelta64(1, 'D')
|
||||
assert type(ts + td64) == Timestamp
|
||||
assert type(ts - td64) == Timestamp
|
||||
|
||||
def test_addition_subtraction_preserve_frequency(self):
|
||||
ts = Timestamp('2014-03-05', freq='D')
|
||||
td = timedelta(days=1)
|
||||
original_freq = ts.freq
|
||||
|
||||
assert (ts + 1).freq == original_freq
|
||||
assert (ts - 1).freq == original_freq
|
||||
assert (ts + td).freq == original_freq
|
||||
assert (ts - td).freq == original_freq
|
||||
|
||||
td64 = np.timedelta64(1, 'D')
|
||||
assert (ts + td64).freq == original_freq
|
||||
assert (ts - td64).freq == original_freq
|
||||
-193
@@ -1,193 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
from datetime import datetime
|
||||
import operator
|
||||
|
||||
import pytest
|
||||
import numpy as np
|
||||
|
||||
from dateutil.tz import tzutc
|
||||
from pytz import utc
|
||||
|
||||
from pandas.compat import long, PY2
|
||||
from pandas import Timestamp
|
||||
|
||||
|
||||
class TestTimestampComparison(object):
|
||||
def test_comparison_object_array(self):
|
||||
# GH#15183
|
||||
ts = Timestamp('2011-01-03 00:00:00-0500', tz='US/Eastern')
|
||||
other = Timestamp('2011-01-01 00:00:00-0500', tz='US/Eastern')
|
||||
naive = Timestamp('2011-01-01 00:00:00')
|
||||
|
||||
arr = np.array([other, ts], dtype=object)
|
||||
res = arr == ts
|
||||
expected = np.array([False, True], dtype=bool)
|
||||
assert (res == expected).all()
|
||||
|
||||
# 2D case
|
||||
arr = np.array([[other, ts],
|
||||
[ts, other]],
|
||||
dtype=object)
|
||||
res = arr != ts
|
||||
expected = np.array([[True, False], [False, True]], dtype=bool)
|
||||
assert res.shape == expected.shape
|
||||
assert (res == expected).all()
|
||||
|
||||
# tzaware mismatch
|
||||
arr = np.array([naive], dtype=object)
|
||||
with pytest.raises(TypeError):
|
||||
arr < ts
|
||||
|
||||
def test_comparison(self):
|
||||
# 5-18-2012 00:00:00.000
|
||||
stamp = long(1337299200000000000)
|
||||
|
||||
val = Timestamp(stamp)
|
||||
|
||||
assert val == val
|
||||
assert not val != val
|
||||
assert not val < val
|
||||
assert val <= val
|
||||
assert not val > val
|
||||
assert val >= val
|
||||
|
||||
other = datetime(2012, 5, 18)
|
||||
assert val == other
|
||||
assert not val != other
|
||||
assert not val < other
|
||||
assert val <= other
|
||||
assert not val > other
|
||||
assert val >= other
|
||||
|
||||
other = Timestamp(stamp + 100)
|
||||
|
||||
assert val != other
|
||||
assert val != other
|
||||
assert val < other
|
||||
assert val <= other
|
||||
assert other > val
|
||||
assert other >= val
|
||||
|
||||
def test_compare_invalid(self):
|
||||
# GH 8058
|
||||
val = Timestamp('20130101 12:01:02')
|
||||
assert not val == 'foo'
|
||||
assert not val == 10.0
|
||||
assert not val == 1
|
||||
assert not val == long(1)
|
||||
assert not val == []
|
||||
assert not val == {'foo': 1}
|
||||
assert not val == np.float64(1)
|
||||
assert not val == np.int64(1)
|
||||
|
||||
assert val != 'foo'
|
||||
assert val != 10.0
|
||||
assert val != 1
|
||||
assert val != long(1)
|
||||
assert val != []
|
||||
assert val != {'foo': 1}
|
||||
assert val != np.float64(1)
|
||||
assert val != np.int64(1)
|
||||
|
||||
def test_cant_compare_tz_naive_w_aware(self):
|
||||
# see gh-1404
|
||||
a = Timestamp('3/12/2012')
|
||||
b = Timestamp('3/12/2012', tz='utc')
|
||||
|
||||
pytest.raises(Exception, a.__eq__, b)
|
||||
pytest.raises(Exception, a.__ne__, b)
|
||||
pytest.raises(Exception, a.__lt__, b)
|
||||
pytest.raises(Exception, a.__gt__, b)
|
||||
pytest.raises(Exception, b.__eq__, a)
|
||||
pytest.raises(Exception, b.__ne__, a)
|
||||
pytest.raises(Exception, b.__lt__, a)
|
||||
pytest.raises(Exception, b.__gt__, a)
|
||||
|
||||
if PY2:
|
||||
pytest.raises(Exception, a.__eq__, b.to_pydatetime())
|
||||
pytest.raises(Exception, a.to_pydatetime().__eq__, b)
|
||||
else:
|
||||
assert not a == b.to_pydatetime()
|
||||
assert not a.to_pydatetime() == b
|
||||
|
||||
def test_cant_compare_tz_naive_w_aware_explicit_pytz(self):
|
||||
# see gh-1404
|
||||
a = Timestamp('3/12/2012')
|
||||
b = Timestamp('3/12/2012', tz=utc)
|
||||
|
||||
pytest.raises(Exception, a.__eq__, b)
|
||||
pytest.raises(Exception, a.__ne__, b)
|
||||
pytest.raises(Exception, a.__lt__, b)
|
||||
pytest.raises(Exception, a.__gt__, b)
|
||||
pytest.raises(Exception, b.__eq__, a)
|
||||
pytest.raises(Exception, b.__ne__, a)
|
||||
pytest.raises(Exception, b.__lt__, a)
|
||||
pytest.raises(Exception, b.__gt__, a)
|
||||
|
||||
if PY2:
|
||||
pytest.raises(Exception, a.__eq__, b.to_pydatetime())
|
||||
pytest.raises(Exception, a.to_pydatetime().__eq__, b)
|
||||
else:
|
||||
assert not a == b.to_pydatetime()
|
||||
assert not a.to_pydatetime() == b
|
||||
|
||||
def test_cant_compare_tz_naive_w_aware_dateutil(self):
|
||||
# see gh-1404
|
||||
a = Timestamp('3/12/2012')
|
||||
b = Timestamp('3/12/2012', tz=tzutc())
|
||||
|
||||
pytest.raises(Exception, a.__eq__, b)
|
||||
pytest.raises(Exception, a.__ne__, b)
|
||||
pytest.raises(Exception, a.__lt__, b)
|
||||
pytest.raises(Exception, a.__gt__, b)
|
||||
pytest.raises(Exception, b.__eq__, a)
|
||||
pytest.raises(Exception, b.__ne__, a)
|
||||
pytest.raises(Exception, b.__lt__, a)
|
||||
pytest.raises(Exception, b.__gt__, a)
|
||||
|
||||
if PY2:
|
||||
pytest.raises(Exception, a.__eq__, b.to_pydatetime())
|
||||
pytest.raises(Exception, a.to_pydatetime().__eq__, b)
|
||||
else:
|
||||
assert not a == b.to_pydatetime()
|
||||
assert not a.to_pydatetime() == b
|
||||
|
||||
def test_timestamp_compare_scalars(self):
|
||||
# case where ndim == 0
|
||||
lhs = np.datetime64(datetime(2013, 12, 6))
|
||||
rhs = Timestamp('now')
|
||||
nat = Timestamp('nat')
|
||||
|
||||
ops = {'gt': 'lt',
|
||||
'lt': 'gt',
|
||||
'ge': 'le',
|
||||
'le': 'ge',
|
||||
'eq': 'eq',
|
||||
'ne': 'ne'}
|
||||
|
||||
for left, right in ops.items():
|
||||
left_f = getattr(operator, left)
|
||||
right_f = getattr(operator, right)
|
||||
expected = left_f(lhs, rhs)
|
||||
|
||||
result = right_f(rhs, lhs)
|
||||
assert result == expected
|
||||
|
||||
expected = left_f(rhs, nat)
|
||||
result = right_f(nat, rhs)
|
||||
assert result == expected
|
||||
|
||||
def test_timestamp_compare_with_early_datetime(self):
|
||||
# e.g. datetime.min
|
||||
stamp = Timestamp('2012-01-01')
|
||||
|
||||
assert not stamp == datetime.min
|
||||
assert not stamp == datetime(1600, 1, 1)
|
||||
assert not stamp == datetime(2700, 1, 1)
|
||||
assert stamp != datetime.min
|
||||
assert stamp != datetime(1600, 1, 1)
|
||||
assert stamp != datetime(2700, 1, 1)
|
||||
assert stamp > datetime(1600, 1, 1)
|
||||
assert stamp >= datetime(1600, 1, 1)
|
||||
assert stamp < datetime(2700, 1, 1)
|
||||
assert stamp <= datetime(2700, 1, 1)
|
||||
-96
@@ -1,96 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
import pytest
|
||||
import dateutil
|
||||
import pytz # noqa # a test below uses pytz but only inside a `eval` call
|
||||
|
||||
import pprint
|
||||
from distutils.version import LooseVersion
|
||||
|
||||
from pandas import Timestamp
|
||||
|
||||
|
||||
class TestTimestampRendering(object):
|
||||
|
||||
# dateutil zone change (only matters for repr)
|
||||
if LooseVersion(dateutil.__version__) >= LooseVersion('2.6.0'):
|
||||
timezones = ['UTC', 'Asia/Tokyo', 'US/Eastern',
|
||||
'dateutil/US/Pacific']
|
||||
else:
|
||||
timezones = ['UTC', 'Asia/Tokyo', 'US/Eastern',
|
||||
'dateutil/America/Los_Angeles']
|
||||
|
||||
@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 = "'{0}'".format(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))
|
||||
|
||||
date_freq = Timestamp(date, freq=freq)
|
||||
assert date in repr(date_freq)
|
||||
assert tz_repr not in repr(date_freq)
|
||||
assert freq_repr in repr(date_freq)
|
||||
assert date_freq == eval(repr(date_freq))
|
||||
|
||||
date_tz_freq = Timestamp(date, tz=tz, freq=freq)
|
||||
assert date in repr(date_tz_freq)
|
||||
assert tz_repr in repr(date_tz_freq)
|
||||
assert freq_repr in repr(date_tz_freq)
|
||||
assert date_tz_freq == eval(repr(date_tz_freq))
|
||||
|
||||
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 'pytz.FixedOffset(-240)' in repr(date_with_utc_offset)
|
||||
expr = repr(date_with_utc_offset).replace("'pytz.FixedOffset(-240)'",
|
||||
'pytz.FixedOffset(-240)')
|
||||
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
|
||||
-898
@@ -1,898 +0,0 @@
|
||||
""" test the scalar Timestamp """
|
||||
|
||||
import pytz
|
||||
import pytest
|
||||
import dateutil
|
||||
import calendar
|
||||
import locale
|
||||
import numpy as np
|
||||
|
||||
from dateutil.tz import tzutc
|
||||
from pytz import timezone, utc
|
||||
from datetime import datetime, timedelta
|
||||
|
||||
import pandas.util.testing as tm
|
||||
import pandas.util._test_decorators as td
|
||||
|
||||
from pandas.tseries import offsets
|
||||
|
||||
from pandas._libs.tslibs import conversion
|
||||
from pandas._libs.tslibs.timezones import get_timezone, dateutil_gettz as gettz
|
||||
|
||||
from pandas.errors import OutOfBoundsDatetime
|
||||
from pandas.compat import long, PY3
|
||||
from pandas.compat.numpy import np_datetime64_compat
|
||||
from pandas import Timestamp, Period, Timedelta, NaT
|
||||
|
||||
|
||||
class TestTimestampProperties(object):
|
||||
|
||||
def test_properties_business(self):
|
||||
ts = Timestamp('2017-10-01', freq='B')
|
||||
control = Timestamp('2017-10-01')
|
||||
assert ts.dayofweek == 6
|
||||
assert not ts.is_month_start # not a weekday
|
||||
assert not ts.is_quarter_start # not a weekday
|
||||
# Control case: non-business is month/qtr start
|
||||
assert control.is_month_start
|
||||
assert control.is_quarter_start
|
||||
|
||||
ts = Timestamp('2017-09-30', freq='B')
|
||||
control = Timestamp('2017-09-30')
|
||||
assert ts.dayofweek == 5
|
||||
assert not ts.is_month_end # not a weekday
|
||||
assert not ts.is_quarter_end # not a weekday
|
||||
# Control case: non-business is month/qtr start
|
||||
assert control.is_month_end
|
||||
assert control.is_quarter_end
|
||||
|
||||
def test_fields(self):
|
||||
def check(value, equal):
|
||||
# that we are int/long like
|
||||
assert isinstance(value, (int, long))
|
||||
assert value == equal
|
||||
|
||||
# GH 10050
|
||||
ts = Timestamp('2015-05-10 09:06:03.000100001')
|
||||
check(ts.year, 2015)
|
||||
check(ts.month, 5)
|
||||
check(ts.day, 10)
|
||||
check(ts.hour, 9)
|
||||
check(ts.minute, 6)
|
||||
check(ts.second, 3)
|
||||
pytest.raises(AttributeError, lambda: ts.millisecond)
|
||||
check(ts.microsecond, 100)
|
||||
check(ts.nanosecond, 1)
|
||||
check(ts.dayofweek, 6)
|
||||
check(ts.quarter, 2)
|
||||
check(ts.dayofyear, 130)
|
||||
check(ts.week, 19)
|
||||
check(ts.daysinmonth, 31)
|
||||
check(ts.daysinmonth, 31)
|
||||
|
||||
# GH 13303
|
||||
ts = Timestamp('2014-12-31 23:59:00-05:00', tz='US/Eastern')
|
||||
check(ts.year, 2014)
|
||||
check(ts.month, 12)
|
||||
check(ts.day, 31)
|
||||
check(ts.hour, 23)
|
||||
check(ts.minute, 59)
|
||||
check(ts.second, 0)
|
||||
pytest.raises(AttributeError, lambda: ts.millisecond)
|
||||
check(ts.microsecond, 0)
|
||||
check(ts.nanosecond, 0)
|
||||
check(ts.dayofweek, 2)
|
||||
check(ts.quarter, 4)
|
||||
check(ts.dayofyear, 365)
|
||||
check(ts.week, 1)
|
||||
check(ts.daysinmonth, 31)
|
||||
|
||||
ts = Timestamp('2014-01-01 00:00:00+01:00')
|
||||
starts = ['is_month_start', 'is_quarter_start', 'is_year_start']
|
||||
for start in starts:
|
||||
assert getattr(ts, start)
|
||||
ts = Timestamp('2014-12-31 23:59:59+01:00')
|
||||
ends = ['is_month_end', 'is_year_end', 'is_quarter_end']
|
||||
for end in ends:
|
||||
assert getattr(ts, end)
|
||||
|
||||
# GH 12806
|
||||
@pytest.mark.parametrize('data',
|
||||
[Timestamp('2017-08-28 23:00:00'),
|
||||
Timestamp('2017-08-28 23:00:00', tz='EST')])
|
||||
@pytest.mark.parametrize('time_locale', [
|
||||
None] if tm.get_locales() is None else [None] + tm.get_locales())
|
||||
def test_names(self, data, time_locale):
|
||||
# GH 17354
|
||||
# Test .weekday_name, .day_name(), .month_name
|
||||
with tm.assert_produces_warning(FutureWarning,
|
||||
check_stacklevel=False):
|
||||
assert data.weekday_name == 'Monday'
|
||||
if time_locale is None:
|
||||
expected_day = 'Monday'
|
||||
expected_month = 'August'
|
||||
else:
|
||||
with tm.set_locale(time_locale, locale.LC_TIME):
|
||||
expected_day = calendar.day_name[0].capitalize()
|
||||
expected_month = calendar.month_name[8].capitalize()
|
||||
|
||||
assert data.day_name(time_locale) == expected_day
|
||||
assert data.month_name(time_locale) == expected_month
|
||||
|
||||
# Test NaT
|
||||
nan_ts = Timestamp(NaT)
|
||||
assert np.isnan(nan_ts.day_name(time_locale))
|
||||
assert np.isnan(nan_ts.month_name(time_locale))
|
||||
|
||||
def test_is_leap_year(self, tz_naive_fixture):
|
||||
tz = tz_naive_fixture
|
||||
# GH 13727
|
||||
dt = Timestamp('2000-01-01 00:00:00', tz=tz)
|
||||
assert dt.is_leap_year
|
||||
assert isinstance(dt.is_leap_year, bool)
|
||||
|
||||
dt = Timestamp('1999-01-01 00:00:00', tz=tz)
|
||||
assert not dt.is_leap_year
|
||||
|
||||
dt = Timestamp('2004-01-01 00:00:00', tz=tz)
|
||||
assert dt.is_leap_year
|
||||
|
||||
dt = Timestamp('2100-01-01 00:00:00', tz=tz)
|
||||
assert not dt.is_leap_year
|
||||
|
||||
def test_woy_boundary(self):
|
||||
# make sure weeks at year boundaries are correct
|
||||
d = datetime(2013, 12, 31)
|
||||
result = Timestamp(d).week
|
||||
expected = 1 # ISO standard
|
||||
assert result == expected
|
||||
|
||||
d = datetime(2008, 12, 28)
|
||||
result = Timestamp(d).week
|
||||
expected = 52 # ISO standard
|
||||
assert result == expected
|
||||
|
||||
d = datetime(2009, 12, 31)
|
||||
result = Timestamp(d).week
|
||||
expected = 53 # ISO standard
|
||||
assert result == expected
|
||||
|
||||
d = datetime(2010, 1, 1)
|
||||
result = Timestamp(d).week
|
||||
expected = 53 # ISO standard
|
||||
assert result == expected
|
||||
|
||||
d = datetime(2010, 1, 3)
|
||||
result = Timestamp(d).week
|
||||
expected = 53 # ISO standard
|
||||
assert result == expected
|
||||
|
||||
result = np.array([Timestamp(datetime(*args)).week
|
||||
for args in [(2000, 1, 1), (2000, 1, 2), (
|
||||
2005, 1, 1), (2005, 1, 2)]])
|
||||
assert (result == [52, 52, 53, 53]).all()
|
||||
|
||||
|
||||
class TestTimestampConstructors(object):
|
||||
|
||||
def test_constructor(self):
|
||||
base_str = '2014-07-01 09:00'
|
||||
base_dt = datetime(2014, 7, 1, 9)
|
||||
base_expected = 1404205200000000000
|
||||
|
||||
# confirm base representation is correct
|
||||
import calendar
|
||||
assert (calendar.timegm(base_dt.timetuple()) * 1000000000 ==
|
||||
base_expected)
|
||||
|
||||
tests = [(base_str, base_dt, base_expected),
|
||||
('2014-07-01 10:00', datetime(2014, 7, 1, 10),
|
||||
base_expected + 3600 * 1000000000),
|
||||
('2014-07-01 09:00:00.000008000',
|
||||
datetime(2014, 7, 1, 9, 0, 0, 8),
|
||||
base_expected + 8000),
|
||||
('2014-07-01 09:00:00.000000005',
|
||||
Timestamp('2014-07-01 09:00:00.000000005'),
|
||||
base_expected + 5)]
|
||||
|
||||
timezones = [(None, 0), ('UTC', 0), (pytz.utc, 0), ('Asia/Tokyo', 9),
|
||||
('US/Eastern', -4), ('dateutil/US/Pacific', -7),
|
||||
(pytz.FixedOffset(-180), -3),
|
||||
(dateutil.tz.tzoffset(None, 18000), 5)]
|
||||
|
||||
for date_str, date, expected in tests:
|
||||
for result in [Timestamp(date_str), Timestamp(date)]:
|
||||
# only with timestring
|
||||
assert result.value == expected
|
||||
assert conversion.pydt_to_i8(result) == expected
|
||||
|
||||
# re-creation shouldn't affect to internal value
|
||||
result = Timestamp(result)
|
||||
assert result.value == expected
|
||||
assert conversion.pydt_to_i8(result) == expected
|
||||
|
||||
# with timezone
|
||||
for tz, offset in timezones:
|
||||
for result in [Timestamp(date_str, tz=tz), Timestamp(date,
|
||||
tz=tz)]:
|
||||
expected_tz = expected - offset * 3600 * 1000000000
|
||||
assert result.value == expected_tz
|
||||
assert conversion.pydt_to_i8(result) == expected_tz
|
||||
|
||||
# should preserve tz
|
||||
result = Timestamp(result)
|
||||
assert result.value == expected_tz
|
||||
assert conversion.pydt_to_i8(result) == expected_tz
|
||||
|
||||
# should convert to UTC
|
||||
result = Timestamp(result, tz='UTC')
|
||||
expected_utc = expected - offset * 3600 * 1000000000
|
||||
assert result.value == expected_utc
|
||||
assert conversion.pydt_to_i8(result) == expected_utc
|
||||
|
||||
def test_constructor_with_stringoffset(self):
|
||||
# GH 7833
|
||||
base_str = '2014-07-01 11:00:00+02:00'
|
||||
base_dt = datetime(2014, 7, 1, 9)
|
||||
base_expected = 1404205200000000000
|
||||
|
||||
# confirm base representation is correct
|
||||
import calendar
|
||||
assert (calendar.timegm(base_dt.timetuple()) * 1000000000 ==
|
||||
base_expected)
|
||||
|
||||
tests = [(base_str, base_expected),
|
||||
('2014-07-01 12:00:00+02:00',
|
||||
base_expected + 3600 * 1000000000),
|
||||
('2014-07-01 11:00:00.000008000+02:00', base_expected + 8000),
|
||||
('2014-07-01 11:00:00.000000005+02:00', base_expected + 5)]
|
||||
|
||||
timezones = [(None, 0), ('UTC', 0), (pytz.utc, 0), ('Asia/Tokyo', 9),
|
||||
('US/Eastern', -4), ('dateutil/US/Pacific', -7),
|
||||
(pytz.FixedOffset(-180), -3),
|
||||
(dateutil.tz.tzoffset(None, 18000), 5)]
|
||||
|
||||
for date_str, expected in tests:
|
||||
for result in [Timestamp(date_str)]:
|
||||
# only with timestring
|
||||
assert result.value == expected
|
||||
assert conversion.pydt_to_i8(result) == expected
|
||||
|
||||
# re-creation shouldn't affect to internal value
|
||||
result = Timestamp(result)
|
||||
assert result.value == expected
|
||||
assert conversion.pydt_to_i8(result) == expected
|
||||
|
||||
# with timezone
|
||||
for tz, offset in timezones:
|
||||
result = Timestamp(date_str, tz=tz)
|
||||
expected_tz = expected
|
||||
assert result.value == expected_tz
|
||||
assert conversion.pydt_to_i8(result) == expected_tz
|
||||
|
||||
# should preserve tz
|
||||
result = Timestamp(result)
|
||||
assert result.value == expected_tz
|
||||
assert conversion.pydt_to_i8(result) == expected_tz
|
||||
|
||||
# should convert to UTC
|
||||
result = Timestamp(result, tz='UTC')
|
||||
expected_utc = expected
|
||||
assert result.value == expected_utc
|
||||
assert conversion.pydt_to_i8(result) == expected_utc
|
||||
|
||||
# This should be 2013-11-01 05:00 in UTC
|
||||
# converted to Chicago tz
|
||||
result = Timestamp('2013-11-01 00:00:00-0500', tz='America/Chicago')
|
||||
assert result.value == Timestamp('2013-11-01 05:00').value
|
||||
expected = "Timestamp('2013-11-01 00:00:00-0500', tz='America/Chicago')" # noqa
|
||||
assert repr(result) == expected
|
||||
assert result == eval(repr(result))
|
||||
|
||||
# This should be 2013-11-01 05:00 in UTC
|
||||
# converted to Tokyo tz (+09:00)
|
||||
result = Timestamp('2013-11-01 00:00:00-0500', tz='Asia/Tokyo')
|
||||
assert result.value == Timestamp('2013-11-01 05:00').value
|
||||
expected = "Timestamp('2013-11-01 14:00:00+0900', tz='Asia/Tokyo')"
|
||||
assert repr(result) == expected
|
||||
assert result == eval(repr(result))
|
||||
|
||||
# GH11708
|
||||
# This should be 2015-11-18 10:00 in UTC
|
||||
# converted to Asia/Katmandu
|
||||
result = Timestamp("2015-11-18 15:45:00+05:45", tz="Asia/Katmandu")
|
||||
assert result.value == Timestamp("2015-11-18 10:00").value
|
||||
expected = "Timestamp('2015-11-18 15:45:00+0545', tz='Asia/Katmandu')"
|
||||
assert repr(result) == expected
|
||||
assert result == eval(repr(result))
|
||||
|
||||
# This should be 2015-11-18 10:00 in UTC
|
||||
# converted to Asia/Kolkata
|
||||
result = Timestamp("2015-11-18 15:30:00+05:30", tz="Asia/Kolkata")
|
||||
assert result.value == Timestamp("2015-11-18 10:00").value
|
||||
expected = "Timestamp('2015-11-18 15:30:00+0530', tz='Asia/Kolkata')"
|
||||
assert repr(result) == expected
|
||||
assert result == eval(repr(result))
|
||||
|
||||
def test_constructor_invalid(self):
|
||||
with tm.assert_raises_regex(TypeError, 'Cannot convert input'):
|
||||
Timestamp(slice(2))
|
||||
with tm.assert_raises_regex(ValueError, 'Cannot convert Period'):
|
||||
Timestamp(Period('1000-01-01'))
|
||||
|
||||
def test_constructor_invalid_tz(self):
|
||||
# GH#17690
|
||||
with tm.assert_raises_regex(TypeError, 'must be a datetime.tzinfo'):
|
||||
Timestamp('2017-10-22', tzinfo='US/Eastern')
|
||||
|
||||
with tm.assert_raises_regex(ValueError, 'at most one of'):
|
||||
Timestamp('2017-10-22', tzinfo=utc, tz='UTC')
|
||||
|
||||
with tm.assert_raises_regex(ValueError, "Invalid frequency:"):
|
||||
# GH#5168
|
||||
# case where user tries to pass tz as an arg, not kwarg, gets
|
||||
# interpreted as a `freq`
|
||||
Timestamp('2012-01-01', 'US/Pacific')
|
||||
|
||||
def test_constructor_tz_or_tzinfo(self):
|
||||
# GH#17943, GH#17690, GH#5168
|
||||
stamps = [Timestamp(year=2017, month=10, day=22, tz='UTC'),
|
||||
Timestamp(year=2017, month=10, day=22, tzinfo=utc),
|
||||
Timestamp(year=2017, month=10, day=22, tz=utc),
|
||||
Timestamp(datetime(2017, 10, 22), tzinfo=utc),
|
||||
Timestamp(datetime(2017, 10, 22), tz='UTC'),
|
||||
Timestamp(datetime(2017, 10, 22), tz=utc)]
|
||||
assert all(ts == stamps[0] for ts in stamps)
|
||||
|
||||
def test_constructor_positional(self):
|
||||
# see gh-10758
|
||||
with pytest.raises(TypeError):
|
||||
Timestamp(2000, 1)
|
||||
with pytest.raises(ValueError):
|
||||
Timestamp(2000, 0, 1)
|
||||
with pytest.raises(ValueError):
|
||||
Timestamp(2000, 13, 1)
|
||||
with pytest.raises(ValueError):
|
||||
Timestamp(2000, 1, 0)
|
||||
with pytest.raises(ValueError):
|
||||
Timestamp(2000, 1, 32)
|
||||
|
||||
# see gh-11630
|
||||
assert (repr(Timestamp(2015, 11, 12)) ==
|
||||
repr(Timestamp('20151112')))
|
||||
assert (repr(Timestamp(2015, 11, 12, 1, 2, 3, 999999)) ==
|
||||
repr(Timestamp('2015-11-12 01:02:03.999999')))
|
||||
|
||||
def test_constructor_keyword(self):
|
||||
# GH 10758
|
||||
with pytest.raises(TypeError):
|
||||
Timestamp(year=2000, month=1)
|
||||
with pytest.raises(ValueError):
|
||||
Timestamp(year=2000, month=0, day=1)
|
||||
with pytest.raises(ValueError):
|
||||
Timestamp(year=2000, month=13, day=1)
|
||||
with pytest.raises(ValueError):
|
||||
Timestamp(year=2000, month=1, day=0)
|
||||
with pytest.raises(ValueError):
|
||||
Timestamp(year=2000, month=1, day=32)
|
||||
|
||||
assert (repr(Timestamp(year=2015, month=11, day=12)) ==
|
||||
repr(Timestamp('20151112')))
|
||||
|
||||
assert (repr(Timestamp(year=2015, month=11, day=12, hour=1, minute=2,
|
||||
second=3, microsecond=999999)) ==
|
||||
repr(Timestamp('2015-11-12 01:02:03.999999')))
|
||||
|
||||
def test_constructor_fromordinal(self):
|
||||
base = datetime(2000, 1, 1)
|
||||
|
||||
ts = Timestamp.fromordinal(base.toordinal(), freq='D')
|
||||
assert base == ts
|
||||
assert ts.freq == 'D'
|
||||
assert base.toordinal() == ts.toordinal()
|
||||
|
||||
ts = Timestamp.fromordinal(base.toordinal(), tz='US/Eastern')
|
||||
assert Timestamp('2000-01-01', tz='US/Eastern') == ts
|
||||
assert base.toordinal() == ts.toordinal()
|
||||
|
||||
# GH#3042
|
||||
dt = datetime(2011, 4, 16, 0, 0)
|
||||
ts = Timestamp.fromordinal(dt.toordinal())
|
||||
assert ts.to_pydatetime() == dt
|
||||
|
||||
# with a tzinfo
|
||||
stamp = Timestamp('2011-4-16', tz='US/Eastern')
|
||||
dt_tz = stamp.to_pydatetime()
|
||||
ts = Timestamp.fromordinal(dt_tz.toordinal(), tz='US/Eastern')
|
||||
assert ts.to_pydatetime() == dt_tz
|
||||
|
||||
@pytest.mark.parametrize('result', [
|
||||
Timestamp(datetime(2000, 1, 2, 3, 4, 5, 6), nanosecond=1),
|
||||
Timestamp(year=2000, month=1, day=2, hour=3, minute=4, second=5,
|
||||
microsecond=6, nanosecond=1),
|
||||
Timestamp(year=2000, month=1, day=2, hour=3, minute=4, second=5,
|
||||
microsecond=6, nanosecond=1, tz='UTC'),
|
||||
Timestamp(2000, 1, 2, 3, 4, 5, 6, 1, None),
|
||||
Timestamp(2000, 1, 2, 3, 4, 5, 6, 1, pytz.UTC)])
|
||||
def test_constructor_nanosecond(self, result):
|
||||
# GH 18898
|
||||
expected = Timestamp(datetime(2000, 1, 2, 3, 4, 5, 6), tz=result.tz)
|
||||
expected = expected + Timedelta(nanoseconds=1)
|
||||
assert result == expected
|
||||
|
||||
@pytest.mark.parametrize('arg', ['year', 'month', 'day', 'hour', 'minute',
|
||||
'second', 'microsecond', 'nanosecond'])
|
||||
def test_invalid_date_kwarg_with_string_input(self, arg):
|
||||
kwarg = {arg: 1}
|
||||
with pytest.raises(ValueError):
|
||||
Timestamp('2010-10-10 12:59:59.999999999', **kwarg)
|
||||
|
||||
def test_out_of_bounds_value(self):
|
||||
one_us = np.timedelta64(1).astype('timedelta64[us]')
|
||||
|
||||
# By definition we can't go out of bounds in [ns], so we
|
||||
# convert the datetime64s to [us] so we can go out of bounds
|
||||
min_ts_us = np.datetime64(Timestamp.min).astype('M8[us]')
|
||||
max_ts_us = np.datetime64(Timestamp.max).astype('M8[us]')
|
||||
|
||||
# No error for the min/max datetimes
|
||||
Timestamp(min_ts_us)
|
||||
Timestamp(max_ts_us)
|
||||
|
||||
# One us less than the minimum is an error
|
||||
with pytest.raises(ValueError):
|
||||
Timestamp(min_ts_us - one_us)
|
||||
|
||||
# One us more than the maximum is an error
|
||||
with pytest.raises(ValueError):
|
||||
Timestamp(max_ts_us + one_us)
|
||||
|
||||
def test_out_of_bounds_string(self):
|
||||
with pytest.raises(ValueError):
|
||||
Timestamp('1676-01-01')
|
||||
with pytest.raises(ValueError):
|
||||
Timestamp('2263-01-01')
|
||||
|
||||
def test_barely_out_of_bounds(self):
|
||||
# GH#19529
|
||||
# GH#19382 close enough to bounds that dropping nanos would result
|
||||
# in an in-bounds datetime
|
||||
with pytest.raises(OutOfBoundsDatetime):
|
||||
Timestamp('2262-04-11 23:47:16.854775808')
|
||||
|
||||
def test_bounds_with_different_units(self):
|
||||
out_of_bounds_dates = ('1677-09-21', '2262-04-12')
|
||||
|
||||
time_units = ('D', 'h', 'm', 's', 'ms', 'us')
|
||||
|
||||
for date_string in out_of_bounds_dates:
|
||||
for unit in time_units:
|
||||
dt64 = np.datetime64(date_string, dtype='M8[%s]' % unit)
|
||||
with pytest.raises(ValueError):
|
||||
Timestamp(dt64)
|
||||
|
||||
in_bounds_dates = ('1677-09-23', '2262-04-11')
|
||||
|
||||
for date_string in in_bounds_dates:
|
||||
for unit in time_units:
|
||||
dt64 = np.datetime64(date_string, dtype='M8[%s]' % unit)
|
||||
Timestamp(dt64)
|
||||
|
||||
def test_min_valid(self):
|
||||
# Ensure that Timestamp.min is a valid Timestamp
|
||||
Timestamp(Timestamp.min)
|
||||
|
||||
def test_max_valid(self):
|
||||
# Ensure that Timestamp.max is a valid Timestamp
|
||||
Timestamp(Timestamp.max)
|
||||
|
||||
def test_now(self):
|
||||
# GH#9000
|
||||
ts_from_string = Timestamp('now')
|
||||
ts_from_method = Timestamp.now()
|
||||
ts_datetime = datetime.now()
|
||||
|
||||
ts_from_string_tz = Timestamp('now', tz='US/Eastern')
|
||||
ts_from_method_tz = Timestamp.now(tz='US/Eastern')
|
||||
|
||||
# Check that the delta between the times is less than 1s (arbitrarily
|
||||
# small)
|
||||
delta = Timedelta(seconds=1)
|
||||
assert abs(ts_from_method - ts_from_string) < delta
|
||||
assert abs(ts_datetime - ts_from_method) < delta
|
||||
assert abs(ts_from_method_tz - ts_from_string_tz) < delta
|
||||
assert (abs(ts_from_string_tz.tz_localize(None) -
|
||||
ts_from_method_tz.tz_localize(None)) < delta)
|
||||
|
||||
def test_today(self):
|
||||
ts_from_string = Timestamp('today')
|
||||
ts_from_method = Timestamp.today()
|
||||
ts_datetime = datetime.today()
|
||||
|
||||
ts_from_string_tz = Timestamp('today', tz='US/Eastern')
|
||||
ts_from_method_tz = Timestamp.today(tz='US/Eastern')
|
||||
|
||||
# Check that the delta between the times is less than 1s (arbitrarily
|
||||
# small)
|
||||
delta = Timedelta(seconds=1)
|
||||
assert abs(ts_from_method - ts_from_string) < delta
|
||||
assert abs(ts_datetime - ts_from_method) < delta
|
||||
assert abs(ts_from_method_tz - ts_from_string_tz) < delta
|
||||
assert (abs(ts_from_string_tz.tz_localize(None) -
|
||||
ts_from_method_tz.tz_localize(None)) < delta)
|
||||
|
||||
@pytest.mark.parametrize('tz', [None, pytz.timezone('US/Pacific')])
|
||||
def test_disallow_setting_tz(self, tz):
|
||||
# GH 3746
|
||||
ts = Timestamp('2010')
|
||||
with pytest.raises(AttributeError):
|
||||
ts.tz = tz
|
||||
|
||||
@pytest.mark.parametrize('offset', ['+0300', '+0200'])
|
||||
def test_construct_timestamp_near_dst(self, offset):
|
||||
# GH 20854
|
||||
expected = Timestamp('2016-10-30 03:00:00{}'.format(offset),
|
||||
tz='Europe/Helsinki')
|
||||
result = Timestamp(expected, tz='Europe/Helsinki')
|
||||
assert result == expected
|
||||
|
||||
|
||||
class TestTimestamp(object):
|
||||
|
||||
def test_tz(self):
|
||||
tstr = '2014-02-01 09:00'
|
||||
ts = Timestamp(tstr)
|
||||
local = ts.tz_localize('Asia/Tokyo')
|
||||
assert local.hour == 9
|
||||
assert local == Timestamp(tstr, tz='Asia/Tokyo')
|
||||
conv = local.tz_convert('US/Eastern')
|
||||
assert conv == Timestamp('2014-01-31 19:00', tz='US/Eastern')
|
||||
assert conv.hour == 19
|
||||
|
||||
# preserves nanosecond
|
||||
ts = Timestamp(tstr) + offsets.Nano(5)
|
||||
local = ts.tz_localize('Asia/Tokyo')
|
||||
assert local.hour == 9
|
||||
assert local.nanosecond == 5
|
||||
conv = local.tz_convert('US/Eastern')
|
||||
assert conv.nanosecond == 5
|
||||
assert conv.hour == 19
|
||||
|
||||
def test_utc_z_designator(self):
|
||||
assert get_timezone(Timestamp('2014-11-02 01:00Z').tzinfo) == 'UTC'
|
||||
|
||||
def test_asm8(self):
|
||||
np.random.seed(7960929)
|
||||
ns = [Timestamp.min.value, Timestamp.max.value, 1000]
|
||||
|
||||
for n in ns:
|
||||
assert (Timestamp(n).asm8.view('i8') ==
|
||||
np.datetime64(n, 'ns').view('i8') == n)
|
||||
|
||||
assert (Timestamp('nat').asm8.view('i8') ==
|
||||
np.datetime64('nat', 'ns').view('i8'))
|
||||
|
||||
def test_class_ops_pytz(self):
|
||||
def compare(x, y):
|
||||
assert (int(Timestamp(x).value / 1e9) ==
|
||||
int(Timestamp(y).value / 1e9))
|
||||
|
||||
compare(Timestamp.now(), datetime.now())
|
||||
compare(Timestamp.now('UTC'), datetime.now(timezone('UTC')))
|
||||
compare(Timestamp.utcnow(), datetime.utcnow())
|
||||
compare(Timestamp.today(), datetime.today())
|
||||
current_time = calendar.timegm(datetime.now().utctimetuple())
|
||||
compare(Timestamp.utcfromtimestamp(current_time),
|
||||
datetime.utcfromtimestamp(current_time))
|
||||
compare(Timestamp.fromtimestamp(current_time),
|
||||
datetime.fromtimestamp(current_time))
|
||||
|
||||
date_component = datetime.utcnow()
|
||||
time_component = (date_component + timedelta(minutes=10)).time()
|
||||
compare(Timestamp.combine(date_component, time_component),
|
||||
datetime.combine(date_component, time_component))
|
||||
|
||||
def test_class_ops_dateutil(self):
|
||||
def compare(x, y):
|
||||
assert (int(np.round(Timestamp(x).value / 1e9)) ==
|
||||
int(np.round(Timestamp(y).value / 1e9)))
|
||||
|
||||
compare(Timestamp.now(), datetime.now())
|
||||
compare(Timestamp.now('UTC'), datetime.now(tzutc()))
|
||||
compare(Timestamp.utcnow(), datetime.utcnow())
|
||||
compare(Timestamp.today(), datetime.today())
|
||||
current_time = calendar.timegm(datetime.now().utctimetuple())
|
||||
compare(Timestamp.utcfromtimestamp(current_time),
|
||||
datetime.utcfromtimestamp(current_time))
|
||||
compare(Timestamp.fromtimestamp(current_time),
|
||||
datetime.fromtimestamp(current_time))
|
||||
|
||||
date_component = datetime.utcnow()
|
||||
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(946684800000000000).view('M8[ns]')
|
||||
stamp = Timestamp(val.view('i8') + 500)
|
||||
assert stamp.year == 2000
|
||||
assert stamp.month == 1
|
||||
assert stamp.microsecond == 0
|
||||
assert stamp.nanosecond == 500
|
||||
|
||||
# GH 14415
|
||||
val = np.iinfo(np.int64).min + 80000000000000
|
||||
stamp = Timestamp(val)
|
||||
assert stamp.year == 1677
|
||||
assert stamp.month == 9
|
||||
assert stamp.day == 21
|
||||
assert stamp.microsecond == 145224
|
||||
assert stamp.nanosecond == 192
|
||||
|
||||
@pytest.mark.parametrize('value, check_kwargs', [
|
||||
[946688461000000000, {}],
|
||||
[946688461000000000 / long(1000), dict(unit='us')],
|
||||
[946688461000000000 / long(1000000), dict(unit='ms')],
|
||||
[946688461000000000 / long(1000000000), dict(unit='s')],
|
||||
[10957, dict(unit='D', h=0)],
|
||||
pytest.param((946688461000000000 + 500000) / long(1000000000),
|
||||
dict(unit='s', us=499, ns=964),
|
||||
marks=pytest.mark.skipif(not PY3,
|
||||
reason='using truediv, so these'
|
||||
' are like floats')),
|
||||
pytest.param((946688461000000000 + 500000000) / long(1000000000),
|
||||
dict(unit='s', us=500000),
|
||||
marks=pytest.mark.skipif(not PY3,
|
||||
reason='using truediv, so these'
|
||||
' are like floats')),
|
||||
pytest.param((946688461000000000 + 500000) / long(1000000),
|
||||
dict(unit='ms', us=500),
|
||||
marks=pytest.mark.skipif(not PY3,
|
||||
reason='using truediv, so these'
|
||||
' are like floats')),
|
||||
pytest.param((946688461000000000 + 500000) / long(1000000000),
|
||||
dict(unit='s'),
|
||||
marks=pytest.mark.skipif(PY3,
|
||||
reason='get chopped in py2')),
|
||||
pytest.param((946688461000000000 + 500000000) / long(1000000000),
|
||||
dict(unit='s'),
|
||||
marks=pytest.mark.skipif(PY3,
|
||||
reason='get chopped in py2')),
|
||||
pytest.param((946688461000000000 + 500000) / long(1000000),
|
||||
dict(unit='ms'),
|
||||
marks=pytest.mark.skipif(PY3,
|
||||
reason='get chopped in py2')),
|
||||
[(946688461000000000 + 500000) / long(1000), dict(unit='us', us=500)],
|
||||
[(946688461000000000 + 500000000) / long(1000000),
|
||||
dict(unit='ms', us=500000)],
|
||||
[946688461000000000 / 1000.0 + 5, dict(unit='us', us=5)],
|
||||
[946688461000000000 / 1000.0 + 5000, dict(unit='us', us=5000)],
|
||||
[946688461000000000 / 1000000.0 + 0.5, dict(unit='ms', us=500)],
|
||||
[946688461000000000 / 1000000.0 + 0.005, dict(unit='ms', us=5, ns=5)],
|
||||
[946688461000000000 / 1000000000.0 + 0.5, dict(unit='s', us=500000)],
|
||||
[10957 + 0.5, dict(unit='D', h=12)]])
|
||||
def test_unit(self, value, check_kwargs):
|
||||
def check(value, unit=None, h=1, s=1, us=0, ns=0):
|
||||
stamp = Timestamp(value, unit=unit)
|
||||
assert stamp.year == 2000
|
||||
assert stamp.month == 1
|
||||
assert stamp.day == 1
|
||||
assert stamp.hour == h
|
||||
if unit != 'D':
|
||||
assert stamp.minute == 1
|
||||
assert stamp.second == s
|
||||
assert stamp.microsecond == us
|
||||
else:
|
||||
assert stamp.minute == 0
|
||||
assert stamp.second == 0
|
||||
assert stamp.microsecond == 0
|
||||
assert stamp.nanosecond == ns
|
||||
|
||||
check(value, **check_kwargs)
|
||||
|
||||
def test_roundtrip(self):
|
||||
|
||||
# test value to string and back conversions
|
||||
# further test accessors
|
||||
base = Timestamp('20140101 00:00:00')
|
||||
|
||||
result = Timestamp(base.value + Timedelta('5ms').value)
|
||||
assert result == Timestamp(str(base) + ".005000")
|
||||
assert result.microsecond == 5000
|
||||
|
||||
result = Timestamp(base.value + Timedelta('5us').value)
|
||||
assert result == Timestamp(str(base) + ".000005")
|
||||
assert result.microsecond == 5
|
||||
|
||||
result = Timestamp(base.value + Timedelta('5ns').value)
|
||||
assert result == Timestamp(str(base) + ".000000005")
|
||||
assert result.nanosecond == 5
|
||||
assert result.microsecond == 0
|
||||
|
||||
result = Timestamp(base.value + Timedelta('6ms 5us').value)
|
||||
assert result == Timestamp(str(base) + ".006005")
|
||||
assert result.microsecond == 5 + 6 * 1000
|
||||
|
||||
result = Timestamp(base.value + Timedelta('200ms 5us').value)
|
||||
assert result == Timestamp(str(base) + ".200005")
|
||||
assert result.microsecond == 5 + 200 * 1000
|
||||
|
||||
def test_hash_equivalent(self):
|
||||
d = {datetime(2011, 1, 1): 5}
|
||||
stamp = Timestamp(datetime(2011, 1, 1))
|
||||
assert d[stamp] == 5
|
||||
|
||||
|
||||
class TestTimestampNsOperations(object):
|
||||
|
||||
def setup_method(self, method):
|
||||
self.timestamp = Timestamp(datetime.utcnow())
|
||||
|
||||
def assert_ns_timedelta(self, modified_timestamp, expected_value):
|
||||
value = self.timestamp.value
|
||||
modified_value = modified_timestamp.value
|
||||
|
||||
assert modified_value - value == expected_value
|
||||
|
||||
def test_timedelta_ns_arithmetic(self):
|
||||
self.assert_ns_timedelta(self.timestamp + np.timedelta64(-123, 'ns'),
|
||||
-123)
|
||||
|
||||
def test_timedelta_ns_based_arithmetic(self):
|
||||
self.assert_ns_timedelta(self.timestamp + np.timedelta64(
|
||||
1234567898, 'ns'), 1234567898)
|
||||
|
||||
def test_timedelta_us_arithmetic(self):
|
||||
self.assert_ns_timedelta(self.timestamp + np.timedelta64(-123, 'us'),
|
||||
-123000)
|
||||
|
||||
def test_timedelta_ms_arithmetic(self):
|
||||
time = self.timestamp + np.timedelta64(-123, 'ms')
|
||||
self.assert_ns_timedelta(time, -123000000)
|
||||
|
||||
def test_nanosecond_string_parsing(self):
|
||||
ts = Timestamp('2013-05-01 07:15:45.123456789')
|
||||
# GH 7878
|
||||
expected_repr = '2013-05-01 07:15:45.123456789'
|
||||
expected_value = 1367392545123456789
|
||||
assert ts.value == expected_value
|
||||
assert expected_repr in repr(ts)
|
||||
|
||||
ts = Timestamp('2013-05-01 07:15:45.123456789+09:00', tz='Asia/Tokyo')
|
||||
assert ts.value == expected_value - 9 * 3600 * 1000000000
|
||||
assert expected_repr in repr(ts)
|
||||
|
||||
ts = Timestamp('2013-05-01 07:15:45.123456789', tz='UTC')
|
||||
assert ts.value == expected_value
|
||||
assert expected_repr in repr(ts)
|
||||
|
||||
ts = Timestamp('2013-05-01 07:15:45.123456789', tz='US/Eastern')
|
||||
assert ts.value == expected_value + 4 * 3600 * 1000000000
|
||||
assert expected_repr in repr(ts)
|
||||
|
||||
# GH 10041
|
||||
ts = Timestamp('20130501T071545.123456789')
|
||||
assert ts.value == expected_value
|
||||
assert expected_repr in repr(ts)
|
||||
|
||||
def test_nanosecond_timestamp(self):
|
||||
# GH 7610
|
||||
expected = 1293840000000000005
|
||||
t = Timestamp('2011-01-01') + offsets.Nano(5)
|
||||
assert repr(t) == "Timestamp('2011-01-01 00:00:00.000000005')"
|
||||
assert t.value == expected
|
||||
assert t.nanosecond == 5
|
||||
|
||||
t = Timestamp(t)
|
||||
assert repr(t) == "Timestamp('2011-01-01 00:00:00.000000005')"
|
||||
assert t.value == expected
|
||||
assert t.nanosecond == 5
|
||||
|
||||
t = Timestamp(np_datetime64_compat('2011-01-01 00:00:00.000000005Z'))
|
||||
assert repr(t) == "Timestamp('2011-01-01 00:00:00.000000005')"
|
||||
assert t.value == expected
|
||||
assert t.nanosecond == 5
|
||||
|
||||
expected = 1293840000000000010
|
||||
t = t + offsets.Nano(5)
|
||||
assert repr(t) == "Timestamp('2011-01-01 00:00:00.000000010')"
|
||||
assert t.value == expected
|
||||
assert t.nanosecond == 10
|
||||
|
||||
t = Timestamp(t)
|
||||
assert repr(t) == "Timestamp('2011-01-01 00:00:00.000000010')"
|
||||
assert t.value == expected
|
||||
assert t.nanosecond == 10
|
||||
|
||||
t = Timestamp(np_datetime64_compat('2011-01-01 00:00:00.000000010Z'))
|
||||
assert repr(t) == "Timestamp('2011-01-01 00:00:00.000000010')"
|
||||
assert t.value == expected
|
||||
assert t.nanosecond == 10
|
||||
|
||||
|
||||
class TestTimestampToJulianDate(object):
|
||||
|
||||
def test_compare_1700(self):
|
||||
r = Timestamp('1700-06-23').to_julian_date()
|
||||
assert r == 2342145.5
|
||||
|
||||
def test_compare_2000(self):
|
||||
r = Timestamp('2000-04-12').to_julian_date()
|
||||
assert r == 2451646.5
|
||||
|
||||
def test_compare_2100(self):
|
||||
r = Timestamp('2100-08-12').to_julian_date()
|
||||
assert r == 2488292.5
|
||||
|
||||
def test_compare_hour01(self):
|
||||
r = Timestamp('2000-08-12T01:00:00').to_julian_date()
|
||||
assert r == 2451768.5416666666666666
|
||||
|
||||
def test_compare_hour13(self):
|
||||
r = Timestamp('2000-08-12T13:00:00').to_julian_date()
|
||||
assert r == 2451769.0416666666666666
|
||||
|
||||
|
||||
class TestTimestampConversion(object):
|
||||
def test_conversion(self):
|
||||
# GH#9255
|
||||
ts = Timestamp('2000-01-01')
|
||||
|
||||
result = ts.to_pydatetime()
|
||||
expected = datetime(2000, 1, 1)
|
||||
assert result == expected
|
||||
assert type(result) == type(expected)
|
||||
|
||||
result = ts.to_datetime64()
|
||||
expected = np.datetime64(ts.value, 'ns')
|
||||
assert result == expected
|
||||
assert type(result) == type(expected)
|
||||
assert result.dtype == expected.dtype
|
||||
|
||||
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,
|
||||
check_stacklevel=False):
|
||||
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', freq='D')
|
||||
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', freq='D')
|
||||
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'), freq='D')
|
||||
dtval = stamp.to_pydatetime()
|
||||
assert stamp == dtval
|
||||
assert stamp.tzinfo == dtval.tzinfo
|
||||
|
||||
@td.skip_if_windows_python_3
|
||||
def test_timestamp_to_datetime_explicit_dateutil(self):
|
||||
stamp = Timestamp('20090415', tz=gettz('US/Eastern'), freq='D')
|
||||
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, check_stacklevel=False):
|
||||
assert (Timestamp(Timestamp.max.to_pydatetime()).value / 1000 ==
|
||||
Timestamp.max.value / 1000)
|
||||
|
||||
exp_warning = None if Timestamp.min.nanosecond == 0 else UserWarning
|
||||
with tm.assert_produces_warning(exp_warning, check_stacklevel=False):
|
||||
assert (Timestamp(Timestamp.min.to_pydatetime()).value / 1000 ==
|
||||
Timestamp.min.value / 1000)
|
||||
-292
@@ -1,292 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
Tests for Timestamp timezone-related methods
|
||||
"""
|
||||
from datetime import date, timedelta
|
||||
|
||||
from distutils.version import LooseVersion
|
||||
import pytest
|
||||
import pytz
|
||||
from pytz.exceptions import AmbiguousTimeError, NonExistentTimeError
|
||||
import dateutil
|
||||
from dateutil.tz import gettz, tzoffset
|
||||
|
||||
import pandas.util.testing as tm
|
||||
import pandas.util._test_decorators as td
|
||||
|
||||
from pandas import Timestamp, NaT
|
||||
from pandas.errors import OutOfBoundsDatetime
|
||||
|
||||
|
||||
class TestTimestampTZOperations(object):
|
||||
# --------------------------------------------------------------
|
||||
# Timestamp.tz_localize
|
||||
|
||||
def test_tz_localize_pushes_out_of_bounds(self):
|
||||
# GH#12677
|
||||
# tz_localize that pushes away from the boundary is OK
|
||||
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):
|
||||
Timestamp.min.tz_localize('Asia/Tokyo')
|
||||
|
||||
# tz_localize that pushes away from the boundary is OK
|
||||
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):
|
||||
Timestamp.max.tz_localize('US/Pacific')
|
||||
|
||||
def test_tz_localize_ambiguous_bool(self):
|
||||
# make sure that we are correctly accepting bool values as ambiguous
|
||||
# GH#14402
|
||||
ts = Timestamp('2015-11-01 01:00:03')
|
||||
expected0 = Timestamp('2015-11-01 01:00:03-0500', tz='US/Central')
|
||||
expected1 = Timestamp('2015-11-01 01:00:03-0600', tz='US/Central')
|
||||
|
||||
with pytest.raises(pytz.AmbiguousTimeError):
|
||||
ts.tz_localize('US/Central')
|
||||
|
||||
result = ts.tz_localize('US/Central', ambiguous=True)
|
||||
assert result == expected0
|
||||
|
||||
result = ts.tz_localize('US/Central', ambiguous=False)
|
||||
assert result == expected1
|
||||
|
||||
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) / 1e9 == 3600
|
||||
with pytest.raises(ValueError):
|
||||
ts.tz_localize('US/Eastern', ambiguous='infer')
|
||||
|
||||
# GH#8025
|
||||
with tm.assert_raises_regex(TypeError,
|
||||
'Cannot localize tz-aware Timestamp, '
|
||||
'use tz_convert for conversions'):
|
||||
Timestamp('2011-01-01', tz='US/Eastern').tz_localize('Asia/Tokyo')
|
||||
|
||||
with tm.assert_raises_regex(TypeError,
|
||||
'Cannot convert tz-naive Timestamp, '
|
||||
'use tz_localize to localize'):
|
||||
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):
|
||||
ts.tz_localize(tz)
|
||||
with pytest.raises(NonExistentTimeError):
|
||||
ts.tz_localize(tz, errors='raise')
|
||||
assert ts.tz_localize(tz, errors='coerce') is NaT
|
||||
|
||||
def test_tz_localize_errors_ambiguous(self):
|
||||
# GH#13057
|
||||
ts = Timestamp('2015-11-1 01:00')
|
||||
with pytest.raises(AmbiguousTimeError):
|
||||
ts.tz_localize('US/Pacific', errors='coerce')
|
||||
|
||||
@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)
|
||||
|
||||
with pytest.raises(TypeError):
|
||||
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=0)
|
||||
result_dateutil = naive.tz_localize(dateutil_zone, ambiguous=0)
|
||||
assert result_pytz.value == result_dateutil.value
|
||||
assert result_pytz.value == 1382835600000000000
|
||||
|
||||
if LooseVersion(dateutil.__version__) < LooseVersion('2.6.0'):
|
||||
# dateutil 2.6 buggy w.r.t. ambiguous=0
|
||||
# see gh-14621
|
||||
# see https://github.com/dateutil/dateutil/issues/321
|
||||
assert (result_pytz.to_pydatetime().tzname() ==
|
||||
result_dateutil.to_pydatetime().tzname())
|
||||
assert str(result_pytz) == str(result_dateutil)
|
||||
elif LooseVersion(dateutil.__version__) > LooseVersion('2.6.0'):
|
||||
# fixed ambiguous behavior
|
||||
assert result_pytz.to_pydatetime().tzname() == 'GMT'
|
||||
assert result_dateutil.to_pydatetime().tzname() == 'BST'
|
||||
assert str(result_pytz) != str(result_dateutil)
|
||||
|
||||
# 1 hour difference
|
||||
result_pytz = naive.tz_localize(pytz_zone, ambiguous=1)
|
||||
result_dateutil = naive.tz_localize(dateutil_zone, ambiguous=1)
|
||||
assert result_pytz.value == result_dateutil.value
|
||||
assert result_pytz.value == 1382832000000000000
|
||||
|
||||
# dateutil < 2.6 is buggy w.r.t. ambiguous timezones
|
||||
if LooseVersion(dateutil.__version__) > LooseVersion('2.5.3'):
|
||||
# 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
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# 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 pandas._libs.tslibs.timezones import maybe_get_tz
|
||||
|
||||
# from system utc to real utc
|
||||
ts = Timestamp('2001-01-05 11:56', tz=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=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
|
||||
|
||||
def test_timestamp_constructor_tz_utc(self):
|
||||
utc_stamp = Timestamp('3/11/2012 05:00', tz='utc')
|
||||
assert utc_stamp.tzinfo is pytz.utc
|
||||
assert utc_stamp.hour == 5
|
||||
|
||||
utc_stamp = Timestamp('3/11/2012 05:00').tz_localize('utc')
|
||||
assert utc_stamp.hour == 5
|
||||
|
||||
def test_timestamp_to_datetime_tzoffset(self):
|
||||
tzinfo = tzoffset(None, 7200)
|
||||
expected = Timestamp('3/11/2012 04:00', tz=tzinfo)
|
||||
result = Timestamp(expected.to_pydatetime())
|
||||
assert expected == result
|
||||
|
||||
def test_timestamp_constructor_near_dst_boundary(self):
|
||||
# GH#11481 & GH#15777
|
||||
# Naive string timestamps were being localized incorrectly
|
||||
# with tz_convert_single instead of tz_localize_to_utc
|
||||
|
||||
for tz in ['Europe/Brussels', 'Europe/Prague']:
|
||||
result = Timestamp('2015-10-25 01:00', tz=tz)
|
||||
expected = Timestamp('2015-10-25 01:00').tz_localize(tz)
|
||||
assert result == expected
|
||||
|
||||
with pytest.raises(pytz.AmbiguousTimeError):
|
||||
Timestamp('2015-10-25 02:00', tz=tz)
|
||||
|
||||
result = Timestamp('2017-03-26 01:00', tz='Europe/Paris')
|
||||
expected = Timestamp('2017-03-26 01:00').tz_localize('Europe/Paris')
|
||||
assert result == expected
|
||||
|
||||
with pytest.raises(pytz.NonExistentTimeError):
|
||||
Timestamp('2017-03-26 02:00', tz='Europe/Paris')
|
||||
|
||||
# GH#11708
|
||||
naive = Timestamp('2015-11-18 10:00:00')
|
||||
result = naive.tz_localize('UTC').tz_convert('Asia/Kolkata')
|
||||
expected = Timestamp('2015-11-18 15:30:00+0530', tz='Asia/Kolkata')
|
||||
assert result == expected
|
||||
|
||||
# GH#15823
|
||||
result = Timestamp('2017-03-26 00:00', tz='Europe/Paris')
|
||||
expected = Timestamp('2017-03-26 00:00:00+0100', tz='Europe/Paris')
|
||||
assert result == expected
|
||||
|
||||
result = Timestamp('2017-03-26 01:00', tz='Europe/Paris')
|
||||
expected = Timestamp('2017-03-26 01:00:00+0100', tz='Europe/Paris')
|
||||
assert result == expected
|
||||
|
||||
with pytest.raises(pytz.NonExistentTimeError):
|
||||
Timestamp('2017-03-26 02:00', tz='Europe/Paris')
|
||||
|
||||
result = Timestamp('2017-03-26 02:00:00+0100', tz='Europe/Paris')
|
||||
naive = Timestamp(result.value)
|
||||
expected = naive.tz_localize('UTC').tz_convert('Europe/Paris')
|
||||
assert result == expected
|
||||
|
||||
result = Timestamp('2017-03-26 03:00', tz='Europe/Paris')
|
||||
expected = Timestamp('2017-03-26 03:00:00+0200', tz='Europe/Paris')
|
||||
assert result == expected
|
||||
|
||||
@pytest.mark.parametrize('tz', [pytz.timezone('US/Eastern'),
|
||||
gettz('US/Eastern'),
|
||||
'US/Eastern', 'dateutil/US/Eastern'])
|
||||
def test_timestamp_constructed_by_date_and_tz(self, tz):
|
||||
# GH#2993, Timestamp cannot be constructed by datetime.date
|
||||
# and tz correctly
|
||||
|
||||
result = Timestamp(date(2012, 3, 11), tz=tz)
|
||||
|
||||
expected = Timestamp('3/11/2012', tz=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
|
||||
-281
@@ -1,281 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
from datetime import datetime
|
||||
|
||||
import pytest
|
||||
import pytz
|
||||
from pytz import utc
|
||||
from dateutil.tz import gettz
|
||||
|
||||
import pandas.util.testing as tm
|
||||
import pandas.util._test_decorators as td
|
||||
|
||||
from pandas.compat import PY3
|
||||
from pandas._libs import tslib
|
||||
from pandas._libs.tslibs.frequencies import _INVALID_FREQ_ERROR
|
||||
from pandas import Timestamp, NaT
|
||||
|
||||
|
||||
class TestTimestampUnaryOps(object):
|
||||
|
||||
# --------------------------------------------------------------
|
||||
# Timestamp.round
|
||||
|
||||
def test_round_day_naive(self):
|
||||
dt = Timestamp('20130101 09:10:11')
|
||||
result = dt.round('D')
|
||||
expected = Timestamp('20130101')
|
||||
assert result == expected
|
||||
|
||||
dt = Timestamp('20130101 19:10:11')
|
||||
result = dt.round('D')
|
||||
expected = Timestamp('20130102')
|
||||
assert result == expected
|
||||
|
||||
dt = Timestamp('20130201 12:00:00')
|
||||
result = dt.round('D')
|
||||
expected = Timestamp('20130202')
|
||||
assert result == expected
|
||||
|
||||
dt = Timestamp('20130104 12:00:00')
|
||||
result = dt.round('D')
|
||||
expected = Timestamp('20130105')
|
||||
assert result == expected
|
||||
|
||||
def test_round_tzaware(self):
|
||||
dt = Timestamp('20130101 09:10:11', tz='US/Eastern')
|
||||
result = dt.round('D')
|
||||
expected = Timestamp('20130101', tz='US/Eastern')
|
||||
assert result == expected
|
||||
|
||||
dt = Timestamp('20130101 09:10:11', tz='US/Eastern')
|
||||
result = dt.round('s')
|
||||
assert result == dt
|
||||
|
||||
def test_round_30min(self):
|
||||
# round
|
||||
dt = Timestamp('20130104 12:32:00')
|
||||
result = dt.round('30Min')
|
||||
expected = Timestamp('20130104 12:30:00')
|
||||
assert result == expected
|
||||
|
||||
def test_round_subsecond(self):
|
||||
# GH#14440 & GH#15578
|
||||
result = Timestamp('2016-10-17 12:00:00.0015').round('ms')
|
||||
expected = Timestamp('2016-10-17 12:00:00.002000')
|
||||
assert result == expected
|
||||
|
||||
result = Timestamp('2016-10-17 12:00:00.00149').round('ms')
|
||||
expected = Timestamp('2016-10-17 12:00:00.001000')
|
||||
assert result == expected
|
||||
|
||||
ts = Timestamp('2016-10-17 12:00:00.0015')
|
||||
for freq in ['us', 'ns']:
|
||||
assert ts == ts.round(freq)
|
||||
|
||||
result = Timestamp('2016-10-17 12:00:00.001501031').round('10ns')
|
||||
expected = Timestamp('2016-10-17 12:00:00.001501030')
|
||||
assert result == expected
|
||||
|
||||
def test_round_nonstandard_freq(self):
|
||||
with tm.assert_produces_warning():
|
||||
Timestamp('2016-10-17 12:00:00.001501031').round('1010ns')
|
||||
|
||||
def test_round_invalid_arg(self):
|
||||
stamp = Timestamp('2000-01-05 05:09:15.13')
|
||||
with tm.assert_raises_regex(ValueError, _INVALID_FREQ_ERROR):
|
||||
stamp.round('foo')
|
||||
|
||||
@pytest.mark.parametrize('freq, expected', [
|
||||
('D', Timestamp('2000-01-05 00:00:00')),
|
||||
('H', Timestamp('2000-01-05 05:00:00')),
|
||||
('S', Timestamp('2000-01-05 05:09:15'))])
|
||||
def test_round_frequencies(self, freq, expected):
|
||||
stamp = Timestamp('2000-01-05 05:09:15.13')
|
||||
|
||||
result = stamp.round(freq=freq)
|
||||
assert result == expected
|
||||
|
||||
@pytest.mark.parametrize('test_input, rounder, freq, expected', [
|
||||
('2117-01-01 00:00:45', 'floor', '15s', '2117-01-01 00:00:45'),
|
||||
('2117-01-01 00:00:45', 'ceil', '15s', '2117-01-01 00:00:45'),
|
||||
('2117-01-01 00:00:45.000000012', 'floor', '10ns',
|
||||
'2117-01-01 00:00:45.000000010'),
|
||||
('1823-01-01 00:00:01.000000012', 'ceil', '10ns',
|
||||
'1823-01-01 00:00:01.000000020'),
|
||||
('1823-01-01 00:00:01', 'floor', '1s', '1823-01-01 00:00:01'),
|
||||
('1823-01-01 00:00:01', 'ceil', '1s', '1823-01-01 00:00:01'),
|
||||
('NaT', 'floor', '1s', 'NaT'),
|
||||
('NaT', 'ceil', '1s', 'NaT')
|
||||
])
|
||||
def test_ceil_floor_edge(self, test_input, rounder, freq, expected):
|
||||
dt = Timestamp(test_input)
|
||||
func = getattr(dt, rounder)
|
||||
result = func(freq)
|
||||
|
||||
if dt is NaT:
|
||||
assert result is NaT
|
||||
else:
|
||||
expected = Timestamp(expected)
|
||||
assert result == expected
|
||||
|
||||
@pytest.mark.parametrize('test_input, freq, expected', [
|
||||
('2018-01-01 00:02:06', '2s', '2018-01-01 00:02:06'),
|
||||
('2018-01-01 00:02:00', '2T', '2018-01-01 00:02:00'),
|
||||
('2018-01-01 00:04:00', '4T', '2018-01-01 00:04:00'),
|
||||
('2018-01-01 00:15:00', '15T', '2018-01-01 00:15:00'),
|
||||
('2018-01-01 00:20:00', '20T', '2018-01-01 00:20:00'),
|
||||
('2018-01-01 03:00:00', '3H', '2018-01-01 03:00:00'),
|
||||
])
|
||||
@pytest.mark.parametrize('rounder', ['ceil', 'floor', 'round'])
|
||||
def test_round_minute_freq(self, test_input, freq, expected, rounder):
|
||||
# Ensure timestamps that shouldnt round dont!
|
||||
# GH#21262
|
||||
|
||||
dt = Timestamp(test_input)
|
||||
expected = Timestamp(expected)
|
||||
func = getattr(dt, rounder)
|
||||
result = func(freq)
|
||||
assert result == expected
|
||||
|
||||
def test_ceil(self):
|
||||
dt = Timestamp('20130101 09:10:11')
|
||||
result = dt.ceil('D')
|
||||
expected = Timestamp('20130102')
|
||||
assert result == expected
|
||||
|
||||
def test_floor(self):
|
||||
dt = Timestamp('20130101 09:10:11')
|
||||
result = dt.floor('D')
|
||||
expected = Timestamp('20130101')
|
||||
assert result == expected
|
||||
|
||||
# --------------------------------------------------------------
|
||||
# Timestamp.replace
|
||||
|
||||
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)
|
||||
with pytest.raises(TypeError):
|
||||
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)
|
||||
with pytest.raises(ValueError):
|
||||
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)
|
||||
|
||||
if PY3:
|
||||
# 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)
|
||||
|
||||
if PY3:
|
||||
# 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 = tslib._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
|
||||
|
||||
# --------------------------------------------------------------
|
||||
|
||||
@td.skip_if_windows
|
||||
def test_timestamp(self):
|
||||
# GH#17329
|
||||
# tz-naive --> treat it as if it were UTC for purposes of timestamp()
|
||||
ts = Timestamp.now()
|
||||
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()
|
||||
|
||||
if PY3:
|
||||
# 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()
|
||||
Reference in New Issue
Block a user