Static code analysis and corrections
This commit is contained in:
Kristjan Komlosi
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.
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.
+1123
File diff suppressed because it is too large
Load Diff
+78
@@ -0,0 +1,78 @@
|
||||
from datetime import timedelta
|
||||
|
||||
import pytest
|
||||
|
||||
import numpy as np
|
||||
|
||||
import pandas.util.testing as tm
|
||||
from pandas import (TimedeltaIndex, timedelta_range, Int64Index, Float64Index,
|
||||
Index, Timedelta, NaT)
|
||||
|
||||
|
||||
class TestTimedeltaIndex(object):
|
||||
def test_astype_object(self):
|
||||
idx = timedelta_range(start='1 days', periods=4, freq='D', name='idx')
|
||||
expected_list = [Timedelta('1 days'), Timedelta('2 days'),
|
||||
Timedelta('3 days'), Timedelta('4 days')]
|
||||
result = idx.astype(object)
|
||||
expected = Index(expected_list, dtype=object, name='idx')
|
||||
tm.assert_index_equal(result, expected)
|
||||
assert idx.tolist() == expected_list
|
||||
|
||||
def test_astype_object_with_nat(self):
|
||||
idx = TimedeltaIndex([timedelta(days=1), timedelta(days=2), NaT,
|
||||
timedelta(days=4)], name='idx')
|
||||
expected_list = [Timedelta('1 days'), Timedelta('2 days'), NaT,
|
||||
Timedelta('4 days')]
|
||||
result = idx.astype(object)
|
||||
expected = Index(expected_list, dtype=object, name='idx')
|
||||
tm.assert_index_equal(result, expected)
|
||||
assert idx.tolist() == expected_list
|
||||
|
||||
def test_astype(self):
|
||||
# GH 13149, GH 13209
|
||||
idx = TimedeltaIndex([1e14, 'NaT', NaT, np.NaN])
|
||||
|
||||
result = idx.astype(object)
|
||||
expected = Index([Timedelta('1 days 03:46:40')] + [NaT] * 3,
|
||||
dtype=object)
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
result = idx.astype(int)
|
||||
expected = Int64Index([100000000000000] + [-9223372036854775808] * 3,
|
||||
dtype=np.int64)
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
result = idx.astype(str)
|
||||
expected = Index(str(x) for x in idx)
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
rng = timedelta_range('1 days', periods=10)
|
||||
result = rng.astype('i8')
|
||||
tm.assert_index_equal(result, Index(rng.asi8))
|
||||
tm.assert_numpy_array_equal(rng.asi8, result.values)
|
||||
|
||||
def test_astype_timedelta64(self):
|
||||
# GH 13149, GH 13209
|
||||
idx = TimedeltaIndex([1e14, 'NaT', NaT, np.NaN])
|
||||
|
||||
result = idx.astype('timedelta64')
|
||||
expected = Float64Index([1e+14] + [np.NaN] * 3, dtype='float64')
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
result = idx.astype('timedelta64[ns]')
|
||||
tm.assert_index_equal(result, idx)
|
||||
assert result is not idx
|
||||
|
||||
result = idx.astype('timedelta64[ns]', copy=False)
|
||||
tm.assert_index_equal(result, idx)
|
||||
assert result is idx
|
||||
|
||||
@pytest.mark.parametrize('dtype', [
|
||||
float, 'datetime64', 'datetime64[ns]'])
|
||||
def test_astype_raises(self, dtype):
|
||||
# GH 13149, GH 13209
|
||||
idx = TimedeltaIndex([1e14, 'NaT', NaT, np.NaN])
|
||||
msg = 'Cannot cast TimedeltaIndex to dtype'
|
||||
with tm.assert_raises_regex(TypeError, msg):
|
||||
idx.astype(dtype)
|
||||
+88
@@ -0,0 +1,88 @@
|
||||
import pytest
|
||||
|
||||
import numpy as np
|
||||
from datetime import timedelta
|
||||
|
||||
import pandas as pd
|
||||
import pandas.util.testing as tm
|
||||
from pandas import TimedeltaIndex, timedelta_range, to_timedelta
|
||||
|
||||
|
||||
class TestTimedeltaIndex(object):
|
||||
|
||||
def test_construction_base_constructor(self):
|
||||
arr = [pd.Timedelta('1 days'), pd.NaT, pd.Timedelta('3 days')]
|
||||
tm.assert_index_equal(pd.Index(arr), pd.TimedeltaIndex(arr))
|
||||
tm.assert_index_equal(pd.Index(np.array(arr)),
|
||||
pd.TimedeltaIndex(np.array(arr)))
|
||||
|
||||
arr = [np.nan, pd.NaT, pd.Timedelta('1 days')]
|
||||
tm.assert_index_equal(pd.Index(arr), pd.TimedeltaIndex(arr))
|
||||
tm.assert_index_equal(pd.Index(np.array(arr)),
|
||||
pd.TimedeltaIndex(np.array(arr)))
|
||||
|
||||
def test_constructor(self):
|
||||
expected = TimedeltaIndex(['1 days', '1 days 00:00:05', '2 days',
|
||||
'2 days 00:00:02', '0 days 00:00:03'])
|
||||
result = TimedeltaIndex(['1 days', '1 days, 00:00:05', np.timedelta64(
|
||||
2, 'D'), timedelta(days=2, seconds=2), pd.offsets.Second(3)])
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
# unicode
|
||||
result = TimedeltaIndex([u'1 days', '1 days, 00:00:05', np.timedelta64(
|
||||
2, 'D'), timedelta(days=2, seconds=2), pd.offsets.Second(3)])
|
||||
|
||||
expected = TimedeltaIndex(['0 days 00:00:00', '0 days 00:00:01',
|
||||
'0 days 00:00:02'])
|
||||
tm.assert_index_equal(TimedeltaIndex(range(3), unit='s'), expected)
|
||||
expected = TimedeltaIndex(['0 days 00:00:00', '0 days 00:00:05',
|
||||
'0 days 00:00:09'])
|
||||
tm.assert_index_equal(TimedeltaIndex([0, 5, 9], unit='s'), expected)
|
||||
expected = TimedeltaIndex(
|
||||
['0 days 00:00:00.400', '0 days 00:00:00.450',
|
||||
'0 days 00:00:01.200'])
|
||||
tm.assert_index_equal(TimedeltaIndex([400, 450, 1200], unit='ms'),
|
||||
expected)
|
||||
|
||||
def test_constructor_coverage(self):
|
||||
rng = timedelta_range('1 days', periods=10.5)
|
||||
exp = timedelta_range('1 days', periods=10)
|
||||
tm.assert_index_equal(rng, exp)
|
||||
|
||||
msg = 'periods must be a number, got foo'
|
||||
with tm.assert_raises_regex(TypeError, msg):
|
||||
TimedeltaIndex(start='1 days', periods='foo', freq='D')
|
||||
|
||||
pytest.raises(ValueError, TimedeltaIndex, start='1 days',
|
||||
end='10 days')
|
||||
|
||||
pytest.raises(ValueError, TimedeltaIndex, '1 days')
|
||||
|
||||
# generator expression
|
||||
gen = (timedelta(i) for i in range(10))
|
||||
result = TimedeltaIndex(gen)
|
||||
expected = TimedeltaIndex([timedelta(i) for i in range(10)])
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
# NumPy string array
|
||||
strings = np.array(['1 days', '2 days', '3 days'])
|
||||
result = TimedeltaIndex(strings)
|
||||
expected = to_timedelta([1, 2, 3], unit='d')
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
from_ints = TimedeltaIndex(expected.asi8)
|
||||
tm.assert_index_equal(from_ints, expected)
|
||||
|
||||
# non-conforming freq
|
||||
pytest.raises(ValueError, TimedeltaIndex,
|
||||
['1 days', '2 days', '4 days'], freq='D')
|
||||
|
||||
pytest.raises(ValueError, TimedeltaIndex, periods=10, freq='D')
|
||||
|
||||
def test_constructor_name(self):
|
||||
idx = TimedeltaIndex(start='1 days', periods=1, freq='D', name='TEST')
|
||||
assert idx.name == 'TEST'
|
||||
|
||||
# GH10025
|
||||
idx2 = TimedeltaIndex(idx, name='something else')
|
||||
assert idx2.name == 'something else'
|
||||
+96
@@ -0,0 +1,96 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
import pytest
|
||||
|
||||
import pandas as pd
|
||||
from pandas import TimedeltaIndex
|
||||
|
||||
|
||||
class TestTimedeltaIndexRendering(object):
|
||||
@pytest.mark.parametrize('method', ['__repr__', '__unicode__', '__str__'])
|
||||
def test_representation(self, method):
|
||||
idx1 = TimedeltaIndex([], freq='D')
|
||||
idx2 = TimedeltaIndex(['1 days'], freq='D')
|
||||
idx3 = TimedeltaIndex(['1 days', '2 days'], freq='D')
|
||||
idx4 = TimedeltaIndex(['1 days', '2 days', '3 days'], freq='D')
|
||||
idx5 = TimedeltaIndex(['1 days 00:00:01', '2 days', '3 days'])
|
||||
|
||||
exp1 = """TimedeltaIndex([], dtype='timedelta64[ns]', freq='D')"""
|
||||
|
||||
exp2 = ("TimedeltaIndex(['1 days'], dtype='timedelta64[ns]', "
|
||||
"freq='D')")
|
||||
|
||||
exp3 = ("TimedeltaIndex(['1 days', '2 days'], "
|
||||
"dtype='timedelta64[ns]', freq='D')")
|
||||
|
||||
exp4 = ("TimedeltaIndex(['1 days', '2 days', '3 days'], "
|
||||
"dtype='timedelta64[ns]', freq='D')")
|
||||
|
||||
exp5 = ("TimedeltaIndex(['1 days 00:00:01', '2 days 00:00:00', "
|
||||
"'3 days 00:00:00'], dtype='timedelta64[ns]', freq=None)")
|
||||
|
||||
with pd.option_context('display.width', 300):
|
||||
for idx, expected in zip([idx1, idx2, idx3, idx4, idx5],
|
||||
[exp1, exp2, exp3, exp4, exp5]):
|
||||
result = getattr(idx, method)()
|
||||
assert result == expected
|
||||
|
||||
def test_representation_to_series(self):
|
||||
idx1 = TimedeltaIndex([], freq='D')
|
||||
idx2 = TimedeltaIndex(['1 days'], freq='D')
|
||||
idx3 = TimedeltaIndex(['1 days', '2 days'], freq='D')
|
||||
idx4 = TimedeltaIndex(['1 days', '2 days', '3 days'], freq='D')
|
||||
idx5 = TimedeltaIndex(['1 days 00:00:01', '2 days', '3 days'])
|
||||
|
||||
exp1 = """Series([], dtype: timedelta64[ns])"""
|
||||
|
||||
exp2 = ("0 1 days\n"
|
||||
"dtype: timedelta64[ns]")
|
||||
|
||||
exp3 = ("0 1 days\n"
|
||||
"1 2 days\n"
|
||||
"dtype: timedelta64[ns]")
|
||||
|
||||
exp4 = ("0 1 days\n"
|
||||
"1 2 days\n"
|
||||
"2 3 days\n"
|
||||
"dtype: timedelta64[ns]")
|
||||
|
||||
exp5 = ("0 1 days 00:00:01\n"
|
||||
"1 2 days 00:00:00\n"
|
||||
"2 3 days 00:00:00\n"
|
||||
"dtype: timedelta64[ns]")
|
||||
|
||||
with pd.option_context('display.width', 300):
|
||||
for idx, expected in zip([idx1, idx2, idx3, idx4, idx5],
|
||||
[exp1, exp2, exp3, exp4, exp5]):
|
||||
result = repr(pd.Series(idx))
|
||||
assert result == expected
|
||||
|
||||
def test_summary(self):
|
||||
# GH#9116
|
||||
idx1 = TimedeltaIndex([], freq='D')
|
||||
idx2 = TimedeltaIndex(['1 days'], freq='D')
|
||||
idx3 = TimedeltaIndex(['1 days', '2 days'], freq='D')
|
||||
idx4 = TimedeltaIndex(['1 days', '2 days', '3 days'], freq='D')
|
||||
idx5 = TimedeltaIndex(['1 days 00:00:01', '2 days', '3 days'])
|
||||
|
||||
exp1 = ("TimedeltaIndex: 0 entries\n"
|
||||
"Freq: D")
|
||||
|
||||
exp2 = ("TimedeltaIndex: 1 entries, 1 days to 1 days\n"
|
||||
"Freq: D")
|
||||
|
||||
exp3 = ("TimedeltaIndex: 2 entries, 1 days to 2 days\n"
|
||||
"Freq: D")
|
||||
|
||||
exp4 = ("TimedeltaIndex: 3 entries, 1 days to 3 days\n"
|
||||
"Freq: D")
|
||||
|
||||
exp5 = ("TimedeltaIndex: 3 entries, 1 days 00:00:01 to 3 days "
|
||||
"00:00:00")
|
||||
|
||||
for idx, expected in zip([idx1, idx2, idx3, idx4, idx5],
|
||||
[exp1, exp2, exp3, exp4, exp5]):
|
||||
result = idx._summary()
|
||||
assert result == expected
|
||||
+322
@@ -0,0 +1,322 @@
|
||||
from datetime import timedelta
|
||||
|
||||
import pytest
|
||||
import numpy as np
|
||||
|
||||
import pandas as pd
|
||||
import pandas.util.testing as tm
|
||||
from pandas import TimedeltaIndex, timedelta_range, compat, Index, Timedelta
|
||||
|
||||
|
||||
class TestGetItem(object):
|
||||
def test_getitem(self):
|
||||
idx1 = timedelta_range('1 day', '31 day', freq='D', name='idx')
|
||||
|
||||
for idx in [idx1]:
|
||||
result = idx[0]
|
||||
assert result == Timedelta('1 day')
|
||||
|
||||
result = idx[0:5]
|
||||
expected = timedelta_range('1 day', '5 day', freq='D',
|
||||
name='idx')
|
||||
tm.assert_index_equal(result, expected)
|
||||
assert result.freq == expected.freq
|
||||
|
||||
result = idx[0:10:2]
|
||||
expected = timedelta_range('1 day', '9 day', freq='2D',
|
||||
name='idx')
|
||||
tm.assert_index_equal(result, expected)
|
||||
assert result.freq == expected.freq
|
||||
|
||||
result = idx[-20:-5:3]
|
||||
expected = timedelta_range('12 day', '24 day', freq='3D',
|
||||
name='idx')
|
||||
tm.assert_index_equal(result, expected)
|
||||
assert result.freq == expected.freq
|
||||
|
||||
result = idx[4::-1]
|
||||
expected = TimedeltaIndex(['5 day', '4 day', '3 day',
|
||||
'2 day', '1 day'],
|
||||
freq='-1D', name='idx')
|
||||
tm.assert_index_equal(result, expected)
|
||||
assert result.freq == expected.freq
|
||||
|
||||
|
||||
class TestWhere(object):
|
||||
# placeholder for symmetry with DatetimeIndex and PeriodIndex tests
|
||||
pass
|
||||
|
||||
|
||||
class TestTake(object):
|
||||
def test_take(self):
|
||||
# GH 10295
|
||||
idx1 = timedelta_range('1 day', '31 day', freq='D', name='idx')
|
||||
|
||||
for idx in [idx1]:
|
||||
result = idx.take([0])
|
||||
assert result == Timedelta('1 day')
|
||||
|
||||
result = idx.take([-1])
|
||||
assert result == Timedelta('31 day')
|
||||
|
||||
result = idx.take([0, 1, 2])
|
||||
expected = timedelta_range('1 day', '3 day', freq='D',
|
||||
name='idx')
|
||||
tm.assert_index_equal(result, expected)
|
||||
assert result.freq == expected.freq
|
||||
|
||||
result = idx.take([0, 2, 4])
|
||||
expected = timedelta_range('1 day', '5 day', freq='2D',
|
||||
name='idx')
|
||||
tm.assert_index_equal(result, expected)
|
||||
assert result.freq == expected.freq
|
||||
|
||||
result = idx.take([7, 4, 1])
|
||||
expected = timedelta_range('8 day', '2 day', freq='-3D',
|
||||
name='idx')
|
||||
tm.assert_index_equal(result, expected)
|
||||
assert result.freq == expected.freq
|
||||
|
||||
result = idx.take([3, 2, 5])
|
||||
expected = TimedeltaIndex(['4 day', '3 day', '6 day'], name='idx')
|
||||
tm.assert_index_equal(result, expected)
|
||||
assert result.freq is None
|
||||
|
||||
result = idx.take([-3, 2, 5])
|
||||
expected = TimedeltaIndex(['29 day', '3 day', '6 day'], name='idx')
|
||||
tm.assert_index_equal(result, expected)
|
||||
assert result.freq is None
|
||||
|
||||
def test_take_invalid_kwargs(self):
|
||||
idx = timedelta_range('1 day', '31 day', freq='D', name='idx')
|
||||
indices = [1, 6, 5, 9, 10, 13, 15, 3]
|
||||
|
||||
msg = r"take\(\) got an unexpected keyword argument 'foo'"
|
||||
tm.assert_raises_regex(TypeError, msg, idx.take,
|
||||
indices, foo=2)
|
||||
|
||||
msg = "the 'out' parameter is not supported"
|
||||
tm.assert_raises_regex(ValueError, msg, idx.take,
|
||||
indices, out=indices)
|
||||
|
||||
msg = "the 'mode' parameter is not supported"
|
||||
tm.assert_raises_regex(ValueError, msg, idx.take,
|
||||
indices, mode='clip')
|
||||
|
||||
# TODO: This method came from test_timedelta; de-dup with version above
|
||||
def test_take2(self):
|
||||
tds = ['1day 02:00:00', '1 day 04:00:00', '1 day 10:00:00']
|
||||
idx = TimedeltaIndex(start='1d', end='2d', freq='H', name='idx')
|
||||
expected = TimedeltaIndex(tds, freq=None, name='idx')
|
||||
|
||||
taken1 = idx.take([2, 4, 10])
|
||||
taken2 = idx[[2, 4, 10]]
|
||||
|
||||
for taken in [taken1, taken2]:
|
||||
tm.assert_index_equal(taken, expected)
|
||||
assert isinstance(taken, TimedeltaIndex)
|
||||
assert taken.freq is None
|
||||
assert taken.name == expected.name
|
||||
|
||||
def test_take_fill_value(self):
|
||||
# GH 12631
|
||||
idx = TimedeltaIndex(['1 days', '2 days', '3 days'],
|
||||
name='xxx')
|
||||
result = idx.take(np.array([1, 0, -1]))
|
||||
expected = TimedeltaIndex(['2 days', '1 days', '3 days'],
|
||||
name='xxx')
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
# fill_value
|
||||
result = idx.take(np.array([1, 0, -1]), fill_value=True)
|
||||
expected = TimedeltaIndex(['2 days', '1 days', 'NaT'],
|
||||
name='xxx')
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
# allow_fill=False
|
||||
result = idx.take(np.array([1, 0, -1]), allow_fill=False,
|
||||
fill_value=True)
|
||||
expected = TimedeltaIndex(['2 days', '1 days', '3 days'],
|
||||
name='xxx')
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
msg = ('When allow_fill=True and fill_value is not None, '
|
||||
'all indices must be >= -1')
|
||||
with tm.assert_raises_regex(ValueError, msg):
|
||||
idx.take(np.array([1, 0, -2]), fill_value=True)
|
||||
with tm.assert_raises_regex(ValueError, msg):
|
||||
idx.take(np.array([1, 0, -5]), fill_value=True)
|
||||
|
||||
with pytest.raises(IndexError):
|
||||
idx.take(np.array([1, -5]))
|
||||
|
||||
|
||||
class TestTimedeltaIndex(object):
|
||||
|
||||
def test_insert(self):
|
||||
|
||||
idx = TimedeltaIndex(['4day', '1day', '2day'], name='idx')
|
||||
|
||||
result = idx.insert(2, timedelta(days=5))
|
||||
exp = TimedeltaIndex(['4day', '1day', '5day', '2day'], name='idx')
|
||||
tm.assert_index_equal(result, exp)
|
||||
|
||||
# insertion of non-datetime should coerce to object index
|
||||
result = idx.insert(1, 'inserted')
|
||||
expected = Index([Timedelta('4day'), 'inserted', Timedelta('1day'),
|
||||
Timedelta('2day')], name='idx')
|
||||
assert not isinstance(result, TimedeltaIndex)
|
||||
tm.assert_index_equal(result, expected)
|
||||
assert result.name == expected.name
|
||||
|
||||
idx = timedelta_range('1day 00:00:01', periods=3, freq='s', name='idx')
|
||||
|
||||
# preserve freq
|
||||
expected_0 = TimedeltaIndex(['1day', '1day 00:00:01', '1day 00:00:02',
|
||||
'1day 00:00:03'],
|
||||
name='idx', freq='s')
|
||||
expected_3 = TimedeltaIndex(['1day 00:00:01', '1day 00:00:02',
|
||||
'1day 00:00:03', '1day 00:00:04'],
|
||||
name='idx', freq='s')
|
||||
|
||||
# reset freq to None
|
||||
expected_1_nofreq = TimedeltaIndex(['1day 00:00:01', '1day 00:00:01',
|
||||
'1day 00:00:02', '1day 00:00:03'],
|
||||
name='idx', freq=None)
|
||||
expected_3_nofreq = TimedeltaIndex(['1day 00:00:01', '1day 00:00:02',
|
||||
'1day 00:00:03', '1day 00:00:05'],
|
||||
name='idx', freq=None)
|
||||
|
||||
cases = [(0, Timedelta('1day'), expected_0),
|
||||
(-3, Timedelta('1day'), expected_0),
|
||||
(3, Timedelta('1day 00:00:04'), expected_3),
|
||||
(1, Timedelta('1day 00:00:01'), expected_1_nofreq),
|
||||
(3, Timedelta('1day 00:00:05'), expected_3_nofreq)]
|
||||
|
||||
for n, d, expected in cases:
|
||||
result = idx.insert(n, d)
|
||||
tm.assert_index_equal(result, expected)
|
||||
assert result.name == expected.name
|
||||
assert result.freq == expected.freq
|
||||
|
||||
# GH 18295 (test missing)
|
||||
expected = TimedeltaIndex(['1day', pd.NaT, '2day', '3day'])
|
||||
for na in (np.nan, pd.NaT, None):
|
||||
result = timedelta_range('1day', '3day').insert(1, na)
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
def test_delete(self):
|
||||
idx = timedelta_range(start='1 Days', periods=5, freq='D', name='idx')
|
||||
|
||||
# prserve freq
|
||||
expected_0 = timedelta_range(start='2 Days', periods=4, freq='D',
|
||||
name='idx')
|
||||
expected_4 = timedelta_range(start='1 Days', periods=4, freq='D',
|
||||
name='idx')
|
||||
|
||||
# reset freq to None
|
||||
expected_1 = TimedeltaIndex(
|
||||
['1 day', '3 day', '4 day', '5 day'], freq=None, name='idx')
|
||||
|
||||
cases = {0: expected_0,
|
||||
-5: expected_0,
|
||||
-1: expected_4,
|
||||
4: expected_4,
|
||||
1: expected_1}
|
||||
for n, expected in compat.iteritems(cases):
|
||||
result = idx.delete(n)
|
||||
tm.assert_index_equal(result, expected)
|
||||
assert result.name == expected.name
|
||||
assert result.freq == expected.freq
|
||||
|
||||
with pytest.raises((IndexError, ValueError)):
|
||||
# either depeidnig on numpy version
|
||||
result = idx.delete(5)
|
||||
|
||||
def test_delete_slice(self):
|
||||
idx = timedelta_range(start='1 days', periods=10, freq='D', name='idx')
|
||||
|
||||
# prserve freq
|
||||
expected_0_2 = timedelta_range(start='4 days', periods=7, freq='D',
|
||||
name='idx')
|
||||
expected_7_9 = timedelta_range(start='1 days', periods=7, freq='D',
|
||||
name='idx')
|
||||
|
||||
# reset freq to None
|
||||
expected_3_5 = TimedeltaIndex(['1 d', '2 d', '3 d',
|
||||
'7 d', '8 d', '9 d', '10d'],
|
||||
freq=None, name='idx')
|
||||
|
||||
cases = {(0, 1, 2): expected_0_2,
|
||||
(7, 8, 9): expected_7_9,
|
||||
(3, 4, 5): expected_3_5}
|
||||
for n, expected in compat.iteritems(cases):
|
||||
result = idx.delete(n)
|
||||
tm.assert_index_equal(result, expected)
|
||||
assert result.name == expected.name
|
||||
assert result.freq == expected.freq
|
||||
|
||||
result = idx.delete(slice(n[0], n[-1] + 1))
|
||||
tm.assert_index_equal(result, expected)
|
||||
assert result.name == expected.name
|
||||
assert result.freq == expected.freq
|
||||
|
||||
def test_get_loc(self):
|
||||
idx = pd.to_timedelta(['0 days', '1 days', '2 days'])
|
||||
|
||||
for method in [None, 'pad', 'backfill', 'nearest']:
|
||||
assert idx.get_loc(idx[1], method) == 1
|
||||
assert idx.get_loc(idx[1].to_pytimedelta(), method) == 1
|
||||
assert idx.get_loc(str(idx[1]), method) == 1
|
||||
|
||||
assert idx.get_loc(idx[1], 'pad',
|
||||
tolerance=Timedelta(0)) == 1
|
||||
assert idx.get_loc(idx[1], 'pad',
|
||||
tolerance=np.timedelta64(0, 's')) == 1
|
||||
assert idx.get_loc(idx[1], 'pad',
|
||||
tolerance=timedelta(0)) == 1
|
||||
|
||||
with tm.assert_raises_regex(ValueError,
|
||||
'unit abbreviation w/o a number'):
|
||||
idx.get_loc(idx[1], method='nearest', tolerance='foo')
|
||||
|
||||
with pytest.raises(
|
||||
ValueError,
|
||||
match='tolerance size must match'):
|
||||
idx.get_loc(idx[1], method='nearest',
|
||||
tolerance=[Timedelta(0).to_timedelta64(),
|
||||
Timedelta(0).to_timedelta64()])
|
||||
|
||||
for method, loc in [('pad', 1), ('backfill', 2), ('nearest', 1)]:
|
||||
assert idx.get_loc('1 day 1 hour', method) == loc
|
||||
|
||||
# GH 16909
|
||||
assert idx.get_loc(idx[1].to_timedelta64()) == 1
|
||||
|
||||
# GH 16896
|
||||
assert idx.get_loc('0 days') == 0
|
||||
|
||||
def test_get_loc_nat(self):
|
||||
tidx = TimedeltaIndex(['1 days 01:00:00', 'NaT', '2 days 01:00:00'])
|
||||
|
||||
assert tidx.get_loc(pd.NaT) == 1
|
||||
assert tidx.get_loc(None) == 1
|
||||
assert tidx.get_loc(float('nan')) == 1
|
||||
assert tidx.get_loc(np.nan) == 1
|
||||
|
||||
def test_get_indexer(self):
|
||||
idx = pd.to_timedelta(['0 days', '1 days', '2 days'])
|
||||
tm.assert_numpy_array_equal(idx.get_indexer(idx),
|
||||
np.array([0, 1, 2], dtype=np.intp))
|
||||
|
||||
target = pd.to_timedelta(['-1 hour', '12 hours', '1 day 1 hour'])
|
||||
tm.assert_numpy_array_equal(idx.get_indexer(target, 'pad'),
|
||||
np.array([-1, 0, 1], dtype=np.intp))
|
||||
tm.assert_numpy_array_equal(idx.get_indexer(target, 'backfill'),
|
||||
np.array([0, 1, 2], dtype=np.intp))
|
||||
tm.assert_numpy_array_equal(idx.get_indexer(target, 'nearest'),
|
||||
np.array([0, 1, 1], dtype=np.intp))
|
||||
|
||||
res = idx.get_indexer(target, 'nearest',
|
||||
tolerance=Timedelta('1 hour'))
|
||||
tm.assert_numpy_array_equal(res, np.array([0, -1, 1], dtype=np.intp))
|
||||
@@ -0,0 +1,401 @@
|
||||
import pytest
|
||||
|
||||
import numpy as np
|
||||
from datetime import timedelta
|
||||
|
||||
import pandas as pd
|
||||
import pandas.util.testing as tm
|
||||
from pandas import to_timedelta
|
||||
from pandas import (Series, Timedelta, Timestamp, TimedeltaIndex,
|
||||
timedelta_range,
|
||||
_np_version_under1p10)
|
||||
from pandas._libs.tslib import iNaT
|
||||
from pandas.tests.test_base import Ops
|
||||
from pandas.tseries.offsets import Day, Hour
|
||||
from pandas.core.dtypes.generic import ABCDateOffset
|
||||
|
||||
|
||||
class TestTimedeltaIndexOps(Ops):
|
||||
def setup_method(self, method):
|
||||
super(TestTimedeltaIndexOps, self).setup_method(method)
|
||||
mask = lambda x: isinstance(x, TimedeltaIndex)
|
||||
self.is_valid_objs = [o for o in self.objs if mask(o)]
|
||||
self.not_valid_objs = []
|
||||
|
||||
def test_ops_properties(self):
|
||||
f = lambda x: isinstance(x, TimedeltaIndex)
|
||||
self.check_ops_properties(TimedeltaIndex._field_ops, f)
|
||||
self.check_ops_properties(TimedeltaIndex._object_ops, f)
|
||||
|
||||
def test_minmax(self):
|
||||
|
||||
# monotonic
|
||||
idx1 = TimedeltaIndex(['1 days', '2 days', '3 days'])
|
||||
assert idx1.is_monotonic
|
||||
|
||||
# non-monotonic
|
||||
idx2 = TimedeltaIndex(['1 days', np.nan, '3 days', 'NaT'])
|
||||
assert not idx2.is_monotonic
|
||||
|
||||
for idx in [idx1, idx2]:
|
||||
assert idx.min() == Timedelta('1 days')
|
||||
assert idx.max() == Timedelta('3 days')
|
||||
assert idx.argmin() == 0
|
||||
assert idx.argmax() == 2
|
||||
|
||||
for op in ['min', 'max']:
|
||||
# Return NaT
|
||||
obj = TimedeltaIndex([])
|
||||
assert pd.isna(getattr(obj, op)())
|
||||
|
||||
obj = TimedeltaIndex([pd.NaT])
|
||||
assert pd.isna(getattr(obj, op)())
|
||||
|
||||
obj = TimedeltaIndex([pd.NaT, pd.NaT, pd.NaT])
|
||||
assert pd.isna(getattr(obj, op)())
|
||||
|
||||
def test_numpy_minmax(self):
|
||||
dr = pd.date_range(start='2016-01-15', end='2016-01-20')
|
||||
td = TimedeltaIndex(np.asarray(dr))
|
||||
|
||||
assert np.min(td) == Timedelta('16815 days')
|
||||
assert np.max(td) == Timedelta('16820 days')
|
||||
|
||||
errmsg = "the 'out' parameter is not supported"
|
||||
tm.assert_raises_regex(ValueError, errmsg, np.min, td, out=0)
|
||||
tm.assert_raises_regex(ValueError, errmsg, np.max, td, out=0)
|
||||
|
||||
assert np.argmin(td) == 0
|
||||
assert np.argmax(td) == 5
|
||||
|
||||
if not _np_version_under1p10:
|
||||
errmsg = "the 'out' parameter is not supported"
|
||||
tm.assert_raises_regex(
|
||||
ValueError, errmsg, np.argmin, td, out=0)
|
||||
tm.assert_raises_regex(
|
||||
ValueError, errmsg, np.argmax, td, out=0)
|
||||
|
||||
def test_value_counts_unique(self):
|
||||
# GH 7735
|
||||
|
||||
idx = timedelta_range('1 days 09:00:00', freq='H', periods=10)
|
||||
# create repeated values, 'n'th element is repeated by n+1 times
|
||||
idx = TimedeltaIndex(np.repeat(idx.values, range(1, len(idx) + 1)))
|
||||
|
||||
exp_idx = timedelta_range('1 days 18:00:00', freq='-1H', periods=10)
|
||||
expected = Series(range(10, 0, -1), index=exp_idx, dtype='int64')
|
||||
|
||||
for obj in [idx, Series(idx)]:
|
||||
tm.assert_series_equal(obj.value_counts(), expected)
|
||||
|
||||
expected = timedelta_range('1 days 09:00:00', freq='H', periods=10)
|
||||
tm.assert_index_equal(idx.unique(), expected)
|
||||
|
||||
idx = TimedeltaIndex(['1 days 09:00:00', '1 days 09:00:00',
|
||||
'1 days 09:00:00', '1 days 08:00:00',
|
||||
'1 days 08:00:00', pd.NaT])
|
||||
|
||||
exp_idx = TimedeltaIndex(['1 days 09:00:00', '1 days 08:00:00'])
|
||||
expected = Series([3, 2], index=exp_idx)
|
||||
|
||||
for obj in [idx, Series(idx)]:
|
||||
tm.assert_series_equal(obj.value_counts(), expected)
|
||||
|
||||
exp_idx = TimedeltaIndex(['1 days 09:00:00', '1 days 08:00:00',
|
||||
pd.NaT])
|
||||
expected = Series([3, 2, 1], index=exp_idx)
|
||||
|
||||
for obj in [idx, Series(idx)]:
|
||||
tm.assert_series_equal(obj.value_counts(dropna=False), expected)
|
||||
|
||||
tm.assert_index_equal(idx.unique(), exp_idx)
|
||||
|
||||
def test_nonunique_contains(self):
|
||||
# GH 9512
|
||||
for idx in map(TimedeltaIndex, ([0, 1, 0], [0, 0, -1], [0, -1, -1],
|
||||
['00:01:00', '00:01:00', '00:02:00'],
|
||||
['00:01:00', '00:01:00', '00:00:01'])):
|
||||
assert idx[0] in idx
|
||||
|
||||
def test_unknown_attribute(self):
|
||||
# see gh-9680
|
||||
tdi = pd.timedelta_range(start=0, periods=10, freq='1s')
|
||||
ts = pd.Series(np.random.normal(size=10), index=tdi)
|
||||
assert 'foo' not in ts.__dict__.keys()
|
||||
pytest.raises(AttributeError, lambda: ts.foo)
|
||||
|
||||
def test_order(self):
|
||||
# GH 10295
|
||||
idx1 = TimedeltaIndex(['1 day', '2 day', '3 day'], freq='D',
|
||||
name='idx')
|
||||
idx2 = TimedeltaIndex(
|
||||
['1 hour', '2 hour', '3 hour'], freq='H', name='idx')
|
||||
|
||||
for idx in [idx1, idx2]:
|
||||
ordered = idx.sort_values()
|
||||
tm.assert_index_equal(ordered, idx)
|
||||
assert ordered.freq == idx.freq
|
||||
|
||||
ordered = idx.sort_values(ascending=False)
|
||||
expected = idx[::-1]
|
||||
tm.assert_index_equal(ordered, expected)
|
||||
assert ordered.freq == expected.freq
|
||||
assert ordered.freq.n == -1
|
||||
|
||||
ordered, indexer = idx.sort_values(return_indexer=True)
|
||||
tm.assert_index_equal(ordered, idx)
|
||||
tm.assert_numpy_array_equal(indexer, np.array([0, 1, 2]),
|
||||
check_dtype=False)
|
||||
assert ordered.freq == idx.freq
|
||||
|
||||
ordered, indexer = idx.sort_values(return_indexer=True,
|
||||
ascending=False)
|
||||
tm.assert_index_equal(ordered, idx[::-1])
|
||||
assert ordered.freq == expected.freq
|
||||
assert ordered.freq.n == -1
|
||||
|
||||
idx1 = TimedeltaIndex(['1 hour', '3 hour', '5 hour',
|
||||
'2 hour ', '1 hour'], name='idx1')
|
||||
exp1 = TimedeltaIndex(['1 hour', '1 hour', '2 hour',
|
||||
'3 hour', '5 hour'], name='idx1')
|
||||
|
||||
idx2 = TimedeltaIndex(['1 day', '3 day', '5 day',
|
||||
'2 day', '1 day'], name='idx2')
|
||||
|
||||
# TODO(wesm): unused?
|
||||
# exp2 = TimedeltaIndex(['1 day', '1 day', '2 day',
|
||||
# '3 day', '5 day'], name='idx2')
|
||||
|
||||
# idx3 = TimedeltaIndex([pd.NaT, '3 minute', '5 minute',
|
||||
# '2 minute', pd.NaT], name='idx3')
|
||||
# exp3 = TimedeltaIndex([pd.NaT, pd.NaT, '2 minute', '3 minute',
|
||||
# '5 minute'], name='idx3')
|
||||
|
||||
for idx, expected in [(idx1, exp1), (idx1, exp1), (idx1, exp1)]:
|
||||
ordered = idx.sort_values()
|
||||
tm.assert_index_equal(ordered, expected)
|
||||
assert ordered.freq is None
|
||||
|
||||
ordered = idx.sort_values(ascending=False)
|
||||
tm.assert_index_equal(ordered, expected[::-1])
|
||||
assert ordered.freq is None
|
||||
|
||||
ordered, indexer = idx.sort_values(return_indexer=True)
|
||||
tm.assert_index_equal(ordered, expected)
|
||||
|
||||
exp = np.array([0, 4, 3, 1, 2])
|
||||
tm.assert_numpy_array_equal(indexer, exp, check_dtype=False)
|
||||
assert ordered.freq is None
|
||||
|
||||
ordered, indexer = idx.sort_values(return_indexer=True,
|
||||
ascending=False)
|
||||
tm.assert_index_equal(ordered, expected[::-1])
|
||||
|
||||
exp = np.array([2, 1, 3, 4, 0])
|
||||
tm.assert_numpy_array_equal(indexer, exp, check_dtype=False)
|
||||
assert ordered.freq is None
|
||||
|
||||
def test_drop_duplicates_metadata(self):
|
||||
# GH 10115
|
||||
idx = pd.timedelta_range('1 day', '31 day', freq='D', name='idx')
|
||||
result = idx.drop_duplicates()
|
||||
tm.assert_index_equal(idx, result)
|
||||
assert idx.freq == result.freq
|
||||
|
||||
idx_dup = idx.append(idx)
|
||||
assert idx_dup.freq is None # freq is reset
|
||||
result = idx_dup.drop_duplicates()
|
||||
tm.assert_index_equal(idx, result)
|
||||
assert result.freq is None
|
||||
|
||||
def test_drop_duplicates(self):
|
||||
# to check Index/Series compat
|
||||
base = pd.timedelta_range('1 day', '31 day', freq='D', name='idx')
|
||||
idx = base.append(base[:5])
|
||||
|
||||
res = idx.drop_duplicates()
|
||||
tm.assert_index_equal(res, base)
|
||||
res = Series(idx).drop_duplicates()
|
||||
tm.assert_series_equal(res, Series(base))
|
||||
|
||||
res = idx.drop_duplicates(keep='last')
|
||||
exp = base[5:].append(base[:5])
|
||||
tm.assert_index_equal(res, exp)
|
||||
res = Series(idx).drop_duplicates(keep='last')
|
||||
tm.assert_series_equal(res, Series(exp, index=np.arange(5, 36)))
|
||||
|
||||
res = idx.drop_duplicates(keep=False)
|
||||
tm.assert_index_equal(res, base[5:])
|
||||
res = Series(idx).drop_duplicates(keep=False)
|
||||
tm.assert_series_equal(res, Series(base[5:], index=np.arange(5, 31)))
|
||||
|
||||
@pytest.mark.parametrize('freq', ['D', '3D', '-3D',
|
||||
'H', '2H', '-2H',
|
||||
'T', '2T', 'S', '-3S'])
|
||||
def test_infer_freq(self, freq):
|
||||
# GH#11018
|
||||
idx = pd.timedelta_range('1', freq=freq, periods=10)
|
||||
result = pd.TimedeltaIndex(idx.asi8, freq='infer')
|
||||
tm.assert_index_equal(idx, result)
|
||||
assert result.freq == freq
|
||||
|
||||
def test_nat_new(self):
|
||||
|
||||
idx = pd.timedelta_range('1', freq='D', periods=5, name='x')
|
||||
result = idx._nat_new()
|
||||
exp = pd.TimedeltaIndex([pd.NaT] * 5, name='x')
|
||||
tm.assert_index_equal(result, exp)
|
||||
|
||||
result = idx._nat_new(box=False)
|
||||
exp = np.array([iNaT] * 5, dtype=np.int64)
|
||||
tm.assert_numpy_array_equal(result, exp)
|
||||
|
||||
def test_shift(self):
|
||||
pass # handled in test_arithmetic.py
|
||||
|
||||
def test_repeat(self):
|
||||
index = pd.timedelta_range('1 days', periods=2, freq='D')
|
||||
exp = pd.TimedeltaIndex(['1 days', '1 days', '2 days', '2 days'])
|
||||
for res in [index.repeat(2), np.repeat(index, 2)]:
|
||||
tm.assert_index_equal(res, exp)
|
||||
assert res.freq is None
|
||||
|
||||
index = TimedeltaIndex(['1 days', 'NaT', '3 days'])
|
||||
exp = TimedeltaIndex(['1 days', '1 days', '1 days',
|
||||
'NaT', 'NaT', 'NaT',
|
||||
'3 days', '3 days', '3 days'])
|
||||
for res in [index.repeat(3), np.repeat(index, 3)]:
|
||||
tm.assert_index_equal(res, exp)
|
||||
assert res.freq is None
|
||||
|
||||
def test_nat(self):
|
||||
assert pd.TimedeltaIndex._na_value is pd.NaT
|
||||
assert pd.TimedeltaIndex([])._na_value is pd.NaT
|
||||
|
||||
idx = pd.TimedeltaIndex(['1 days', '2 days'])
|
||||
assert idx._can_hold_na
|
||||
|
||||
tm.assert_numpy_array_equal(idx._isnan, np.array([False, False]))
|
||||
assert not idx.hasnans
|
||||
tm.assert_numpy_array_equal(idx._nan_idxs,
|
||||
np.array([], dtype=np.intp))
|
||||
|
||||
idx = pd.TimedeltaIndex(['1 days', 'NaT'])
|
||||
assert idx._can_hold_na
|
||||
|
||||
tm.assert_numpy_array_equal(idx._isnan, np.array([False, True]))
|
||||
assert idx.hasnans
|
||||
tm.assert_numpy_array_equal(idx._nan_idxs,
|
||||
np.array([1], dtype=np.intp))
|
||||
|
||||
def test_equals(self):
|
||||
# GH 13107
|
||||
idx = pd.TimedeltaIndex(['1 days', '2 days', 'NaT'])
|
||||
assert idx.equals(idx)
|
||||
assert idx.equals(idx.copy())
|
||||
assert idx.equals(idx.astype(object))
|
||||
assert idx.astype(object).equals(idx)
|
||||
assert idx.astype(object).equals(idx.astype(object))
|
||||
assert not idx.equals(list(idx))
|
||||
assert not idx.equals(pd.Series(idx))
|
||||
|
||||
idx2 = pd.TimedeltaIndex(['2 days', '1 days', 'NaT'])
|
||||
assert not idx.equals(idx2)
|
||||
assert not idx.equals(idx2.copy())
|
||||
assert not idx.equals(idx2.astype(object))
|
||||
assert not idx.astype(object).equals(idx2)
|
||||
assert not idx.astype(object).equals(idx2.astype(object))
|
||||
assert not idx.equals(list(idx2))
|
||||
assert not idx.equals(pd.Series(idx2))
|
||||
|
||||
@pytest.mark.parametrize('values', [['0 days', '2 days', '4 days'], []])
|
||||
@pytest.mark.parametrize('freq', ['2D', Day(2), '48H', Hour(48)])
|
||||
def test_freq_setter(self, values, freq):
|
||||
# GH 20678
|
||||
idx = TimedeltaIndex(values)
|
||||
|
||||
# can set to an offset, converting from string if necessary
|
||||
idx.freq = freq
|
||||
assert idx.freq == freq
|
||||
assert isinstance(idx.freq, ABCDateOffset)
|
||||
|
||||
# can reset to None
|
||||
idx.freq = None
|
||||
assert idx.freq is None
|
||||
|
||||
def test_freq_setter_errors(self):
|
||||
# GH 20678
|
||||
idx = TimedeltaIndex(['0 days', '2 days', '4 days'])
|
||||
|
||||
# setting with an incompatible freq
|
||||
msg = ('Inferred frequency 2D from passed values does not conform to '
|
||||
'passed frequency 5D')
|
||||
with tm.assert_raises_regex(ValueError, msg):
|
||||
idx.freq = '5D'
|
||||
|
||||
# setting with a non-fixed frequency
|
||||
msg = '<2 \* BusinessDays> is a non-fixed frequency'
|
||||
with tm.assert_raises_regex(ValueError, msg):
|
||||
idx.freq = '2B'
|
||||
|
||||
# setting with non-freq string
|
||||
with tm.assert_raises_regex(ValueError, 'Invalid frequency'):
|
||||
idx.freq = 'foo'
|
||||
|
||||
|
||||
class TestTimedeltas(object):
|
||||
|
||||
def test_timedelta_ops(self):
|
||||
# GH4984
|
||||
# make sure ops return Timedelta
|
||||
s = Series([Timestamp('20130101') + timedelta(seconds=i * i)
|
||||
for i in range(10)])
|
||||
td = s.diff()
|
||||
|
||||
result = td.mean()
|
||||
expected = to_timedelta(timedelta(seconds=9))
|
||||
assert result == expected
|
||||
|
||||
result = td.to_frame().mean()
|
||||
assert result[0] == expected
|
||||
|
||||
result = td.quantile(.1)
|
||||
expected = Timedelta(np.timedelta64(2600, 'ms'))
|
||||
assert result == expected
|
||||
|
||||
result = td.median()
|
||||
expected = to_timedelta('00:00:09')
|
||||
assert result == expected
|
||||
|
||||
result = td.to_frame().median()
|
||||
assert result[0] == expected
|
||||
|
||||
# GH 6462
|
||||
# consistency in returned values for sum
|
||||
result = td.sum()
|
||||
expected = to_timedelta('00:01:21')
|
||||
assert result == expected
|
||||
|
||||
result = td.to_frame().sum()
|
||||
assert result[0] == expected
|
||||
|
||||
# std
|
||||
result = td.std()
|
||||
expected = to_timedelta(Series(td.dropna().values).std())
|
||||
assert result == expected
|
||||
|
||||
result = td.to_frame().std()
|
||||
assert result[0] == expected
|
||||
|
||||
# invalid ops
|
||||
for op in ['skew', 'kurt', 'sem', 'prod']:
|
||||
pytest.raises(TypeError, getattr(td, op))
|
||||
|
||||
# GH 10040
|
||||
# make sure NaT is properly handled by median()
|
||||
s = Series([Timestamp('2015-02-03'), Timestamp('2015-02-07')])
|
||||
assert s.diff().median() == timedelta(days=4)
|
||||
|
||||
s = Series([Timestamp('2015-02-03'), Timestamp('2015-02-07'),
|
||||
Timestamp('2015-02-15')])
|
||||
assert s.diff().median() == timedelta(days=6)
|
||||
+87
@@ -0,0 +1,87 @@
|
||||
import pytest
|
||||
|
||||
import numpy as np
|
||||
import pandas.util.testing as tm
|
||||
|
||||
import pandas as pd
|
||||
from pandas import Series, timedelta_range, Timedelta
|
||||
from pandas.util.testing import assert_series_equal
|
||||
|
||||
|
||||
class TestSlicing(object):
|
||||
def test_slice_keeps_name(self):
|
||||
# GH4226
|
||||
dr = pd.timedelta_range('1d', '5d', freq='H', name='timebucket')
|
||||
assert dr[1:].name == dr.name
|
||||
|
||||
def test_partial_slice(self):
|
||||
rng = timedelta_range('1 day 10:11:12', freq='h', periods=500)
|
||||
s = Series(np.arange(len(rng)), index=rng)
|
||||
|
||||
result = s['5 day':'6 day']
|
||||
expected = s.iloc[86:134]
|
||||
assert_series_equal(result, expected)
|
||||
|
||||
result = s['5 day':]
|
||||
expected = s.iloc[86:]
|
||||
assert_series_equal(result, expected)
|
||||
|
||||
result = s[:'6 day']
|
||||
expected = s.iloc[:134]
|
||||
assert_series_equal(result, expected)
|
||||
|
||||
result = s['6 days, 23:11:12']
|
||||
assert result == s.iloc[133]
|
||||
|
||||
pytest.raises(KeyError, s.__getitem__, '50 days')
|
||||
|
||||
def test_partial_slice_high_reso(self):
|
||||
|
||||
# higher reso
|
||||
rng = timedelta_range('1 day 10:11:12', freq='us', periods=2000)
|
||||
s = Series(np.arange(len(rng)), index=rng)
|
||||
|
||||
result = s['1 day 10:11:12':]
|
||||
expected = s.iloc[0:]
|
||||
assert_series_equal(result, expected)
|
||||
|
||||
result = s['1 day 10:11:12.001':]
|
||||
expected = s.iloc[1000:]
|
||||
assert_series_equal(result, expected)
|
||||
|
||||
result = s['1 days, 10:11:12.001001']
|
||||
assert result == s.iloc[1001]
|
||||
|
||||
def test_slice_with_negative_step(self):
|
||||
ts = Series(np.arange(20), timedelta_range('0', periods=20, freq='H'))
|
||||
SLC = pd.IndexSlice
|
||||
|
||||
def assert_slices_equivalent(l_slc, i_slc):
|
||||
assert_series_equal(ts[l_slc], ts.iloc[i_slc])
|
||||
assert_series_equal(ts.loc[l_slc], ts.iloc[i_slc])
|
||||
assert_series_equal(ts.loc[l_slc], ts.iloc[i_slc])
|
||||
|
||||
assert_slices_equivalent(SLC[Timedelta(hours=7)::-1], SLC[7::-1])
|
||||
assert_slices_equivalent(SLC['7 hours'::-1], SLC[7::-1])
|
||||
|
||||
assert_slices_equivalent(SLC[:Timedelta(hours=7):-1], SLC[:6:-1])
|
||||
assert_slices_equivalent(SLC[:'7 hours':-1], SLC[:6:-1])
|
||||
|
||||
assert_slices_equivalent(SLC['15 hours':'7 hours':-1], SLC[15:6:-1])
|
||||
assert_slices_equivalent(SLC[Timedelta(hours=15):Timedelta(hours=7):-
|
||||
1], SLC[15:6:-1])
|
||||
assert_slices_equivalent(SLC['15 hours':Timedelta(hours=7):-1],
|
||||
SLC[15:6:-1])
|
||||
assert_slices_equivalent(SLC[Timedelta(hours=15):'7 hours':-1],
|
||||
SLC[15:6:-1])
|
||||
|
||||
assert_slices_equivalent(SLC['7 hours':'15 hours':-1], SLC[:0])
|
||||
|
||||
def test_slice_with_zero_step_raises(self):
|
||||
ts = Series(np.arange(20), timedelta_range('0', periods=20, freq='H'))
|
||||
tm.assert_raises_regex(ValueError, 'slice step cannot be zero',
|
||||
lambda: ts[::0])
|
||||
tm.assert_raises_regex(ValueError, 'slice step cannot be zero',
|
||||
lambda: ts.loc[::0])
|
||||
tm.assert_raises_regex(ValueError, 'slice step cannot be zero',
|
||||
lambda: ts.loc[::0])
|
||||
+63
@@ -0,0 +1,63 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
Tests for TimedeltaIndex methods behaving like their Timedelta counterparts
|
||||
"""
|
||||
|
||||
import numpy as np
|
||||
|
||||
import pandas as pd
|
||||
import pandas.util.testing as tm
|
||||
from pandas import timedelta_range, Timedelta, TimedeltaIndex, Index, Series
|
||||
|
||||
|
||||
class TestVectorizedTimedelta(object):
|
||||
def test_tdi_total_seconds(self):
|
||||
# GH#10939
|
||||
# test index
|
||||
rng = timedelta_range('1 days, 10:11:12.100123456', periods=2,
|
||||
freq='s')
|
||||
expt = [1 * 86400 + 10 * 3600 + 11 * 60 + 12 + 100123456. / 1e9,
|
||||
1 * 86400 + 10 * 3600 + 11 * 60 + 13 + 100123456. / 1e9]
|
||||
tm.assert_almost_equal(rng.total_seconds(), Index(expt))
|
||||
|
||||
# test Series
|
||||
ser = Series(rng)
|
||||
s_expt = Series(expt, index=[0, 1])
|
||||
tm.assert_series_equal(ser.dt.total_seconds(), s_expt)
|
||||
|
||||
# with nat
|
||||
ser[1] = np.nan
|
||||
s_expt = Series([1 * 86400 + 10 * 3600 + 11 * 60 +
|
||||
12 + 100123456. / 1e9, np.nan], index=[0, 1])
|
||||
tm.assert_series_equal(ser.dt.total_seconds(), s_expt)
|
||||
|
||||
# with both nat
|
||||
ser = Series([np.nan, np.nan], dtype='timedelta64[ns]')
|
||||
tm.assert_series_equal(ser.dt.total_seconds(),
|
||||
Series([np.nan, np.nan], index=[0, 1]))
|
||||
|
||||
def test_tdi_round(self):
|
||||
td = pd.timedelta_range(start='16801 days', periods=5, freq='30Min')
|
||||
elt = td[1]
|
||||
|
||||
expected_rng = TimedeltaIndex([Timedelta('16801 days 00:00:00'),
|
||||
Timedelta('16801 days 00:00:00'),
|
||||
Timedelta('16801 days 01:00:00'),
|
||||
Timedelta('16801 days 02:00:00'),
|
||||
Timedelta('16801 days 02:00:00')])
|
||||
expected_elt = expected_rng[1]
|
||||
|
||||
tm.assert_index_equal(td.round(freq='H'), expected_rng)
|
||||
assert elt.round(freq='H') == expected_elt
|
||||
|
||||
msg = pd._libs.tslibs.frequencies._INVALID_FREQ_ERROR
|
||||
with tm.assert_raises_regex(ValueError, msg):
|
||||
td.round(freq='foo')
|
||||
with tm.assert_raises_regex(ValueError, msg):
|
||||
elt.round(freq='foo')
|
||||
|
||||
msg = "<MonthEnd> is a non-fixed frequency"
|
||||
with tm.assert_raises_regex(ValueError, msg):
|
||||
td.round(freq='M')
|
||||
with tm.assert_raises_regex(ValueError, msg):
|
||||
elt.round(freq='M')
|
||||
+75
@@ -0,0 +1,75 @@
|
||||
import numpy as np
|
||||
|
||||
import pandas as pd
|
||||
import pandas.util.testing as tm
|
||||
from pandas import TimedeltaIndex, timedelta_range, Int64Index
|
||||
|
||||
|
||||
class TestTimedeltaIndex(object):
|
||||
|
||||
def test_union(self):
|
||||
|
||||
i1 = timedelta_range('1day', periods=5)
|
||||
i2 = timedelta_range('3day', periods=5)
|
||||
result = i1.union(i2)
|
||||
expected = timedelta_range('1day', periods=7)
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
i1 = Int64Index(np.arange(0, 20, 2))
|
||||
i2 = TimedeltaIndex(start='1 day', periods=10, freq='D')
|
||||
i1.union(i2) # Works
|
||||
i2.union(i1) # Fails with "AttributeError: can't set attribute"
|
||||
|
||||
def test_union_coverage(self):
|
||||
|
||||
idx = TimedeltaIndex(['3d', '1d', '2d'])
|
||||
ordered = TimedeltaIndex(idx.sort_values(), freq='infer')
|
||||
result = ordered.union(idx)
|
||||
tm.assert_index_equal(result, ordered)
|
||||
|
||||
result = ordered[:0].union(ordered)
|
||||
tm.assert_index_equal(result, ordered)
|
||||
assert result.freq == ordered.freq
|
||||
|
||||
def test_union_bug_1730(self):
|
||||
|
||||
rng_a = timedelta_range('1 day', periods=4, freq='3H')
|
||||
rng_b = timedelta_range('1 day', periods=4, freq='4H')
|
||||
|
||||
result = rng_a.union(rng_b)
|
||||
exp = TimedeltaIndex(sorted(set(list(rng_a)) | set(list(rng_b))))
|
||||
tm.assert_index_equal(result, exp)
|
||||
|
||||
def test_union_bug_1745(self):
|
||||
|
||||
left = TimedeltaIndex(['1 day 15:19:49.695000'])
|
||||
right = TimedeltaIndex(['2 day 13:04:21.322000',
|
||||
'1 day 15:27:24.873000',
|
||||
'1 day 15:31:05.350000'])
|
||||
|
||||
result = left.union(right)
|
||||
exp = TimedeltaIndex(sorted(set(list(left)) | set(list(right))))
|
||||
tm.assert_index_equal(result, exp)
|
||||
|
||||
def test_union_bug_4564(self):
|
||||
|
||||
left = timedelta_range("1 day", "30d")
|
||||
right = left + pd.offsets.Minute(15)
|
||||
|
||||
result = left.union(right)
|
||||
exp = TimedeltaIndex(sorted(set(list(left)) | set(list(right))))
|
||||
tm.assert_index_equal(result, exp)
|
||||
|
||||
def test_intersection_bug_1708(self):
|
||||
index_1 = timedelta_range('1 day', periods=4, freq='h')
|
||||
index_2 = index_1 + pd.offsets.Hour(5)
|
||||
|
||||
result = index_1 & index_2
|
||||
assert len(result) == 0
|
||||
|
||||
index_1 = timedelta_range('1 day', periods=4, freq='h')
|
||||
index_2 = index_1 + pd.offsets.Hour(1)
|
||||
|
||||
result = index_1 & index_2
|
||||
expected = timedelta_range('1 day 01:00:00', periods=3, freq='h')
|
||||
tm.assert_index_equal(result, expected)
|
||||
+309
@@ -0,0 +1,309 @@
|
||||
import warnings
|
||||
|
||||
import pytest
|
||||
|
||||
import numpy as np
|
||||
from datetime import timedelta
|
||||
|
||||
import pandas as pd
|
||||
import pandas.util.testing as tm
|
||||
from pandas import (timedelta_range, date_range, Series, Timedelta,
|
||||
TimedeltaIndex, Index, DataFrame,
|
||||
Int64Index)
|
||||
from pandas.util.testing import (assert_almost_equal, assert_series_equal,
|
||||
assert_index_equal)
|
||||
|
||||
from ..datetimelike import DatetimeLike
|
||||
|
||||
randn = np.random.randn
|
||||
|
||||
|
||||
class TestTimedeltaIndex(DatetimeLike):
|
||||
_holder = TimedeltaIndex
|
||||
|
||||
def setup_method(self, method):
|
||||
self.indices = dict(index=tm.makeTimedeltaIndex(10))
|
||||
self.setup_indices()
|
||||
|
||||
def create_index(self):
|
||||
return pd.to_timedelta(range(5), unit='d') + pd.offsets.Hour(1)
|
||||
|
||||
def test_numeric_compat(self):
|
||||
# Dummy method to override super's version; this test is now done
|
||||
# in test_arithmetic.py
|
||||
pass
|
||||
|
||||
def test_shift(self):
|
||||
pass # this is handled in test_arithmetic.py
|
||||
|
||||
def test_pickle_compat_construction(self):
|
||||
pass
|
||||
|
||||
def test_fillna_timedelta(self):
|
||||
# GH 11343
|
||||
idx = pd.TimedeltaIndex(['1 day', pd.NaT, '3 day'])
|
||||
|
||||
exp = pd.TimedeltaIndex(['1 day', '2 day', '3 day'])
|
||||
tm.assert_index_equal(idx.fillna(pd.Timedelta('2 day')), exp)
|
||||
|
||||
exp = pd.TimedeltaIndex(['1 day', '3 hour', '3 day'])
|
||||
idx.fillna(pd.Timedelta('3 hour'))
|
||||
|
||||
exp = pd.Index(
|
||||
[pd.Timedelta('1 day'), 'x', pd.Timedelta('3 day')], dtype=object)
|
||||
tm.assert_index_equal(idx.fillna('x'), exp)
|
||||
|
||||
def test_difference_freq(self):
|
||||
# GH14323: Difference of TimedeltaIndex should not preserve frequency
|
||||
|
||||
index = timedelta_range("0 days", "5 days", freq="D")
|
||||
|
||||
other = timedelta_range("1 days", "4 days", freq="D")
|
||||
expected = TimedeltaIndex(["0 days", "5 days"], freq=None)
|
||||
idx_diff = index.difference(other)
|
||||
tm.assert_index_equal(idx_diff, expected)
|
||||
tm.assert_attr_equal('freq', idx_diff, expected)
|
||||
|
||||
other = timedelta_range("2 days", "5 days", freq="D")
|
||||
idx_diff = index.difference(other)
|
||||
expected = TimedeltaIndex(["0 days", "1 days"], freq=None)
|
||||
tm.assert_index_equal(idx_diff, expected)
|
||||
tm.assert_attr_equal('freq', idx_diff, expected)
|
||||
|
||||
def test_isin(self):
|
||||
|
||||
index = tm.makeTimedeltaIndex(4)
|
||||
result = index.isin(index)
|
||||
assert result.all()
|
||||
|
||||
result = index.isin(list(index))
|
||||
assert result.all()
|
||||
|
||||
assert_almost_equal(index.isin([index[2], 5]),
|
||||
np.array([False, False, True, False]))
|
||||
|
||||
def test_factorize(self):
|
||||
idx1 = TimedeltaIndex(['1 day', '1 day', '2 day', '2 day', '3 day',
|
||||
'3 day'])
|
||||
|
||||
exp_arr = np.array([0, 0, 1, 1, 2, 2], dtype=np.intp)
|
||||
exp_idx = TimedeltaIndex(['1 day', '2 day', '3 day'])
|
||||
|
||||
arr, idx = idx1.factorize()
|
||||
tm.assert_numpy_array_equal(arr, exp_arr)
|
||||
tm.assert_index_equal(idx, exp_idx)
|
||||
|
||||
arr, idx = idx1.factorize(sort=True)
|
||||
tm.assert_numpy_array_equal(arr, exp_arr)
|
||||
tm.assert_index_equal(idx, exp_idx)
|
||||
|
||||
# freq must be preserved
|
||||
idx3 = timedelta_range('1 day', periods=4, freq='s')
|
||||
exp_arr = np.array([0, 1, 2, 3], dtype=np.intp)
|
||||
arr, idx = idx3.factorize()
|
||||
tm.assert_numpy_array_equal(arr, exp_arr)
|
||||
tm.assert_index_equal(idx, idx3)
|
||||
|
||||
def test_join_self(self, join_type):
|
||||
index = timedelta_range('1 day', periods=10)
|
||||
joined = index.join(index, how=join_type)
|
||||
tm.assert_index_equal(index, joined)
|
||||
|
||||
def test_does_not_convert_mixed_integer(self):
|
||||
df = tm.makeCustomDataframe(10, 10,
|
||||
data_gen_f=lambda *args, **kwargs: randn(),
|
||||
r_idx_type='i', c_idx_type='td')
|
||||
str(df)
|
||||
|
||||
cols = df.columns.join(df.index, how='outer')
|
||||
joined = cols.join(df.columns)
|
||||
assert cols.dtype == np.dtype('O')
|
||||
assert cols.dtype == joined.dtype
|
||||
tm.assert_index_equal(cols, joined)
|
||||
|
||||
def test_sort_values(self):
|
||||
|
||||
idx = TimedeltaIndex(['4d', '1d', '2d'])
|
||||
|
||||
ordered = idx.sort_values()
|
||||
assert ordered.is_monotonic
|
||||
|
||||
ordered = idx.sort_values(ascending=False)
|
||||
assert ordered[::-1].is_monotonic
|
||||
|
||||
ordered, dexer = idx.sort_values(return_indexer=True)
|
||||
assert ordered.is_monotonic
|
||||
|
||||
tm.assert_numpy_array_equal(dexer, np.array([1, 2, 0]),
|
||||
check_dtype=False)
|
||||
|
||||
ordered, dexer = idx.sort_values(return_indexer=True, ascending=False)
|
||||
assert ordered[::-1].is_monotonic
|
||||
|
||||
tm.assert_numpy_array_equal(dexer, np.array([0, 2, 1]),
|
||||
check_dtype=False)
|
||||
|
||||
def test_get_duplicates(self):
|
||||
idx = TimedeltaIndex(['1 day', '2 day', '2 day', '3 day', '3day',
|
||||
'4day'])
|
||||
|
||||
with warnings.catch_warnings(record=True):
|
||||
# Deprecated - see GH20239
|
||||
result = idx.get_duplicates()
|
||||
|
||||
ex = TimedeltaIndex(['2 day', '3day'])
|
||||
tm.assert_index_equal(result, ex)
|
||||
|
||||
def test_argmin_argmax(self):
|
||||
idx = TimedeltaIndex(['1 day 00:00:05', '1 day 00:00:01',
|
||||
'1 day 00:00:02'])
|
||||
assert idx.argmin() == 1
|
||||
assert idx.argmax() == 0
|
||||
|
||||
def test_misc_coverage(self):
|
||||
|
||||
rng = timedelta_range('1 day', periods=5)
|
||||
result = rng.groupby(rng.days)
|
||||
assert isinstance(list(result.values())[0][0], Timedelta)
|
||||
|
||||
idx = TimedeltaIndex(['3d', '1d', '2d'])
|
||||
assert not idx.equals(list(idx))
|
||||
|
||||
non_td = Index(list('abc'))
|
||||
assert not idx.equals(list(non_td))
|
||||
|
||||
def test_map(self):
|
||||
# test_map_dictlike generally tests
|
||||
|
||||
rng = timedelta_range('1 day', periods=10)
|
||||
|
||||
f = lambda x: x.days
|
||||
result = rng.map(f)
|
||||
exp = Int64Index([f(x) for x in rng])
|
||||
tm.assert_index_equal(result, exp)
|
||||
|
||||
def test_pass_TimedeltaIndex_to_index(self):
|
||||
|
||||
rng = timedelta_range('1 days', '10 days')
|
||||
idx = Index(rng, dtype=object)
|
||||
|
||||
expected = Index(rng.to_pytimedelta(), dtype=object)
|
||||
|
||||
tm.assert_numpy_array_equal(idx.values, expected.values)
|
||||
|
||||
def test_pickle(self):
|
||||
|
||||
rng = timedelta_range('1 days', periods=10)
|
||||
rng_p = tm.round_trip_pickle(rng)
|
||||
tm.assert_index_equal(rng, rng_p)
|
||||
|
||||
def test_hash_error(self):
|
||||
index = timedelta_range('1 days', periods=10)
|
||||
with tm.assert_raises_regex(TypeError, "unhashable type: %r" %
|
||||
type(index).__name__):
|
||||
hash(index)
|
||||
|
||||
def test_append_join_nondatetimeindex(self):
|
||||
rng = timedelta_range('1 days', periods=10)
|
||||
idx = Index(['a', 'b', 'c', 'd'])
|
||||
|
||||
result = rng.append(idx)
|
||||
assert isinstance(result[0], Timedelta)
|
||||
|
||||
# it works
|
||||
rng.join(idx, how='outer')
|
||||
|
||||
def test_append_numpy_bug_1681(self):
|
||||
|
||||
td = timedelta_range('1 days', '10 days', freq='2D')
|
||||
a = DataFrame()
|
||||
c = DataFrame({'A': 'foo', 'B': td}, index=td)
|
||||
str(c)
|
||||
|
||||
result = a.append(c)
|
||||
assert (result['B'] == td).all()
|
||||
|
||||
def test_fields(self):
|
||||
rng = timedelta_range('1 days, 10:11:12.100123456', periods=2,
|
||||
freq='s')
|
||||
tm.assert_index_equal(rng.days, Index([1, 1], dtype='int64'))
|
||||
tm.assert_index_equal(
|
||||
rng.seconds,
|
||||
Index([10 * 3600 + 11 * 60 + 12, 10 * 3600 + 11 * 60 + 13],
|
||||
dtype='int64'))
|
||||
tm.assert_index_equal(
|
||||
rng.microseconds,
|
||||
Index([100 * 1000 + 123, 100 * 1000 + 123], dtype='int64'))
|
||||
tm.assert_index_equal(rng.nanoseconds,
|
||||
Index([456, 456], dtype='int64'))
|
||||
|
||||
pytest.raises(AttributeError, lambda: rng.hours)
|
||||
pytest.raises(AttributeError, lambda: rng.minutes)
|
||||
pytest.raises(AttributeError, lambda: rng.milliseconds)
|
||||
|
||||
# with nat
|
||||
s = Series(rng)
|
||||
s[1] = np.nan
|
||||
|
||||
tm.assert_series_equal(s.dt.days, Series([1, np.nan], index=[0, 1]))
|
||||
tm.assert_series_equal(s.dt.seconds, Series(
|
||||
[10 * 3600 + 11 * 60 + 12, np.nan], index=[0, 1]))
|
||||
|
||||
# preserve name (GH15589)
|
||||
rng.name = 'name'
|
||||
assert rng.days.name == 'name'
|
||||
|
||||
def test_freq_conversion(self):
|
||||
|
||||
# doc example
|
||||
|
||||
# series
|
||||
td = Series(date_range('20130101', periods=4)) - \
|
||||
Series(date_range('20121201', periods=4))
|
||||
td[2] += timedelta(minutes=5, seconds=3)
|
||||
td[3] = np.nan
|
||||
|
||||
result = td / np.timedelta64(1, 'D')
|
||||
expected = Series([31, 31, (31 * 86400 + 5 * 60 + 3) / 86400.0, np.nan
|
||||
])
|
||||
assert_series_equal(result, expected)
|
||||
|
||||
result = td.astype('timedelta64[D]')
|
||||
expected = Series([31, 31, 31, np.nan])
|
||||
assert_series_equal(result, expected)
|
||||
|
||||
result = td / np.timedelta64(1, 's')
|
||||
expected = Series([31 * 86400, 31 * 86400, 31 * 86400 + 5 * 60 + 3,
|
||||
np.nan])
|
||||
assert_series_equal(result, expected)
|
||||
|
||||
result = td.astype('timedelta64[s]')
|
||||
assert_series_equal(result, expected)
|
||||
|
||||
# tdi
|
||||
td = TimedeltaIndex(td)
|
||||
|
||||
result = td / np.timedelta64(1, 'D')
|
||||
expected = Index([31, 31, (31 * 86400 + 5 * 60 + 3) / 86400.0, np.nan])
|
||||
assert_index_equal(result, expected)
|
||||
|
||||
result = td.astype('timedelta64[D]')
|
||||
expected = Index([31, 31, 31, np.nan])
|
||||
assert_index_equal(result, expected)
|
||||
|
||||
result = td / np.timedelta64(1, 's')
|
||||
expected = Index([31 * 86400, 31 * 86400, 31 * 86400 + 5 * 60 + 3,
|
||||
np.nan])
|
||||
assert_index_equal(result, expected)
|
||||
|
||||
result = td.astype('timedelta64[s]')
|
||||
assert_index_equal(result, expected)
|
||||
|
||||
|
||||
class TestTimeSeries(object):
|
||||
|
||||
def test_series_box_timedelta(self):
|
||||
rng = timedelta_range('1 day 1 s', periods=5, freq='h')
|
||||
s = Series(rng)
|
||||
assert isinstance(s[1], Timedelta)
|
||||
assert isinstance(s.iat[2], Timedelta)
|
||||
+77
@@ -0,0 +1,77 @@
|
||||
import pytest
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
import pandas.util.testing as tm
|
||||
from pandas.tseries.offsets import Day, Second
|
||||
from pandas import to_timedelta, timedelta_range
|
||||
|
||||
|
||||
class TestTimedeltas(object):
|
||||
|
||||
def test_timedelta_range(self):
|
||||
|
||||
expected = to_timedelta(np.arange(5), unit='D')
|
||||
result = timedelta_range('0 days', periods=5, freq='D')
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
expected = to_timedelta(np.arange(11), unit='D')
|
||||
result = timedelta_range('0 days', '10 days', freq='D')
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
expected = to_timedelta(np.arange(5), unit='D') + Second(2) + Day()
|
||||
result = timedelta_range('1 days, 00:00:02', '5 days, 00:00:02',
|
||||
freq='D')
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
expected = to_timedelta([1, 3, 5, 7, 9], unit='D') + Second(2)
|
||||
result = timedelta_range('1 days, 00:00:02', periods=5, freq='2D')
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
expected = to_timedelta(np.arange(50), unit='T') * 30
|
||||
result = timedelta_range('0 days', freq='30T', periods=50)
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
# GH 11776
|
||||
arr = np.arange(10).reshape(2, 5)
|
||||
df = pd.DataFrame(np.arange(10).reshape(2, 5))
|
||||
for arg in (arr, df):
|
||||
with tm.assert_raises_regex(TypeError, "1-d array"):
|
||||
to_timedelta(arg)
|
||||
for errors in ['ignore', 'raise', 'coerce']:
|
||||
with tm.assert_raises_regex(TypeError, "1-d array"):
|
||||
to_timedelta(arg, errors=errors)
|
||||
|
||||
# issue10583
|
||||
df = pd.DataFrame(np.random.normal(size=(10, 4)))
|
||||
df.index = pd.timedelta_range(start='0s', periods=10, freq='s')
|
||||
expected = df.loc[pd.Timedelta('0s'):, :]
|
||||
result = df.loc['0s':, :]
|
||||
tm.assert_frame_equal(expected, result)
|
||||
|
||||
@pytest.mark.parametrize('periods, freq', [
|
||||
(3, '2D'), (5, 'D'), (6, '19H12T'), (7, '16H'), (9, '12H')])
|
||||
def test_linspace_behavior(self, periods, freq):
|
||||
# GH 20976
|
||||
result = timedelta_range(start='0 days', end='4 days', periods=periods)
|
||||
expected = timedelta_range(start='0 days', end='4 days', freq=freq)
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
def test_errors(self):
|
||||
# not enough params
|
||||
msg = ('Of the four parameters: start, end, periods, and freq, '
|
||||
'exactly three must be specified')
|
||||
with tm.assert_raises_regex(ValueError, msg):
|
||||
timedelta_range(start='0 days')
|
||||
|
||||
with tm.assert_raises_regex(ValueError, msg):
|
||||
timedelta_range(end='5 days')
|
||||
|
||||
with tm.assert_raises_regex(ValueError, msg):
|
||||
timedelta_range(periods=2)
|
||||
|
||||
with tm.assert_raises_regex(ValueError, msg):
|
||||
timedelta_range()
|
||||
|
||||
# too many params
|
||||
with tm.assert_raises_regex(ValueError, msg):
|
||||
timedelta_range(start='0 days', end='5 days', periods=10, freq='H')
|
||||
+174
@@ -0,0 +1,174 @@
|
||||
import pytest
|
||||
|
||||
from datetime import time, timedelta
|
||||
import numpy as np
|
||||
|
||||
import pandas as pd
|
||||
import pandas.util.testing as tm
|
||||
from pandas.util.testing import assert_series_equal
|
||||
from pandas import Series, to_timedelta, isna, TimedeltaIndex
|
||||
from pandas._libs.tslib import iNaT
|
||||
|
||||
|
||||
class TestTimedeltas(object):
|
||||
|
||||
def test_to_timedelta(self):
|
||||
def conv(v):
|
||||
return v.astype('m8[ns]')
|
||||
|
||||
d1 = np.timedelta64(1, 'D')
|
||||
|
||||
assert (to_timedelta('1 days 06:05:01.00003', box=False) ==
|
||||
conv(d1 + np.timedelta64(6 * 3600 + 5 * 60 + 1, 's') +
|
||||
np.timedelta64(30, 'us')))
|
||||
assert (to_timedelta('15.5us', box=False) ==
|
||||
conv(np.timedelta64(15500, 'ns')))
|
||||
|
||||
# empty string
|
||||
result = to_timedelta('', box=False)
|
||||
assert result.astype('int64') == iNaT
|
||||
|
||||
result = to_timedelta(['', ''])
|
||||
assert isna(result).all()
|
||||
|
||||
# pass thru
|
||||
result = to_timedelta(np.array([np.timedelta64(1, 's')]))
|
||||
expected = pd.Index(np.array([np.timedelta64(1, 's')]))
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
# ints
|
||||
result = np.timedelta64(0, 'ns')
|
||||
expected = to_timedelta(0, box=False)
|
||||
assert result == expected
|
||||
|
||||
# Series
|
||||
expected = Series([timedelta(days=1), timedelta(days=1, seconds=1)])
|
||||
result = to_timedelta(Series(['1d', '1days 00:00:01']))
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
# with units
|
||||
result = TimedeltaIndex([np.timedelta64(0, 'ns'), np.timedelta64(
|
||||
10, 's').astype('m8[ns]')])
|
||||
expected = to_timedelta([0, 10], unit='s')
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
# single element conversion
|
||||
v = timedelta(seconds=1)
|
||||
result = to_timedelta(v, box=False)
|
||||
expected = np.timedelta64(timedelta(seconds=1))
|
||||
assert result == expected
|
||||
|
||||
v = np.timedelta64(timedelta(seconds=1))
|
||||
result = to_timedelta(v, box=False)
|
||||
expected = np.timedelta64(timedelta(seconds=1))
|
||||
assert result == expected
|
||||
|
||||
# arrays of various dtypes
|
||||
arr = np.array([1] * 5, dtype='int64')
|
||||
result = to_timedelta(arr, unit='s')
|
||||
expected = TimedeltaIndex([np.timedelta64(1, 's')] * 5)
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
arr = np.array([1] * 5, dtype='int64')
|
||||
result = to_timedelta(arr, unit='m')
|
||||
expected = TimedeltaIndex([np.timedelta64(1, 'm')] * 5)
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
arr = np.array([1] * 5, dtype='int64')
|
||||
result = to_timedelta(arr, unit='h')
|
||||
expected = TimedeltaIndex([np.timedelta64(1, 'h')] * 5)
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
arr = np.array([1] * 5, dtype='timedelta64[s]')
|
||||
result = to_timedelta(arr)
|
||||
expected = TimedeltaIndex([np.timedelta64(1, 's')] * 5)
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
arr = np.array([1] * 5, dtype='timedelta64[D]')
|
||||
result = to_timedelta(arr)
|
||||
expected = TimedeltaIndex([np.timedelta64(1, 'D')] * 5)
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
# Test with lists as input when box=false
|
||||
expected = np.array(np.arange(3) * 1000000000, dtype='timedelta64[ns]')
|
||||
result = to_timedelta(range(3), unit='s', box=False)
|
||||
tm.assert_numpy_array_equal(expected, result)
|
||||
|
||||
result = to_timedelta(np.arange(3), unit='s', box=False)
|
||||
tm.assert_numpy_array_equal(expected, result)
|
||||
|
||||
result = to_timedelta([0, 1, 2], unit='s', box=False)
|
||||
tm.assert_numpy_array_equal(expected, result)
|
||||
|
||||
# Tests with fractional seconds as input:
|
||||
expected = np.array(
|
||||
[0, 500000000, 800000000, 1200000000], dtype='timedelta64[ns]')
|
||||
result = to_timedelta([0., 0.5, 0.8, 1.2], unit='s', box=False)
|
||||
tm.assert_numpy_array_equal(expected, result)
|
||||
|
||||
def test_to_timedelta_invalid(self):
|
||||
|
||||
# bad value for errors parameter
|
||||
msg = "errors must be one of"
|
||||
tm.assert_raises_regex(ValueError, msg, to_timedelta,
|
||||
['foo'], errors='never')
|
||||
|
||||
# these will error
|
||||
pytest.raises(ValueError, lambda: to_timedelta([1, 2], unit='foo'))
|
||||
pytest.raises(ValueError, lambda: to_timedelta(1, unit='foo'))
|
||||
|
||||
# time not supported ATM
|
||||
pytest.raises(ValueError, lambda: to_timedelta(time(second=1)))
|
||||
assert to_timedelta(time(second=1), errors='coerce') is pd.NaT
|
||||
|
||||
pytest.raises(ValueError, lambda: to_timedelta(['foo', 'bar']))
|
||||
tm.assert_index_equal(TimedeltaIndex([pd.NaT, pd.NaT]),
|
||||
to_timedelta(['foo', 'bar'], errors='coerce'))
|
||||
|
||||
tm.assert_index_equal(TimedeltaIndex(['1 day', pd.NaT, '1 min']),
|
||||
to_timedelta(['1 day', 'bar', '1 min'],
|
||||
errors='coerce'))
|
||||
|
||||
# gh-13613: these should not error because errors='ignore'
|
||||
invalid_data = 'apple'
|
||||
assert invalid_data == to_timedelta(invalid_data, errors='ignore')
|
||||
|
||||
invalid_data = ['apple', '1 days']
|
||||
tm.assert_numpy_array_equal(
|
||||
np.array(invalid_data, dtype=object),
|
||||
to_timedelta(invalid_data, errors='ignore'))
|
||||
|
||||
invalid_data = pd.Index(['apple', '1 days'])
|
||||
tm.assert_index_equal(invalid_data, to_timedelta(
|
||||
invalid_data, errors='ignore'))
|
||||
|
||||
invalid_data = Series(['apple', '1 days'])
|
||||
tm.assert_series_equal(invalid_data, to_timedelta(
|
||||
invalid_data, errors='ignore'))
|
||||
|
||||
def test_to_timedelta_via_apply(self):
|
||||
# GH 5458
|
||||
expected = Series([np.timedelta64(1, 's')])
|
||||
result = Series(['00:00:01']).apply(to_timedelta)
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
result = Series([to_timedelta('00:00:01')])
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
def test_to_timedelta_on_missing_values(self):
|
||||
# GH5438
|
||||
timedelta_NaT = np.timedelta64('NaT')
|
||||
|
||||
actual = pd.to_timedelta(Series(['00:00:01', np.nan]))
|
||||
expected = Series([np.timedelta64(1000000000, 'ns'),
|
||||
timedelta_NaT], dtype='<m8[ns]')
|
||||
assert_series_equal(actual, expected)
|
||||
|
||||
actual = pd.to_timedelta(Series(['00:00:01', pd.NaT]))
|
||||
assert_series_equal(actual, expected)
|
||||
|
||||
actual = pd.to_timedelta(np.nan)
|
||||
assert actual.value == timedelta_NaT.astype('int64')
|
||||
|
||||
actual = pd.to_timedelta(pd.NaT)
|
||||
assert actual.value == timedelta_NaT.astype('int64')
|
||||
Reference in New Issue
Block a user