921 lines
34 KiB
Python
921 lines
34 KiB
Python
|
# -*- coding: utf-8 -*-
|
||
|
|
|
||
|
|
import itertools
|
||
|
|
import pytest
|
||
|
|
import numpy as np
|
||
|
|
|
||
|
|
import pandas as pd
|
||
|
|
import pandas.util.testing as tm
|
||
|
|
import pandas.compat as compat
|
||
|
|
|
||
|
|
|
||
|
|
###############################################################
|
||
|
|
# Index / Series common tests which may trigger dtype coercions
|
||
|
|
###############################################################
|
||
|
|
|
||
|
|
|
||
|
|
@pytest.fixture(autouse=True, scope='class')
|
||
|
|
def check_comprehensiveness(request):
|
||
|
|
# Iterate over combination of dtype, method and klass
|
||
|
|
# and ensure that each are contained within a collected test
|
||
|
|
cls = request.cls
|
||
|
|
combos = itertools.product(cls.klasses, cls.dtypes, [cls.method])
|
||
|
|
|
||
|
|
def has_test(combo):
|
||
|
|
klass, dtype, method = combo
|
||
|
|
cls_funcs = request.node.session.items
|
||
|
|
return any(klass in x.name and dtype in x.name and
|
||
|
|
method in x.name for x in cls_funcs)
|
||
|
|
|
||
|
|
for combo in combos:
|
||
|
|
if not has_test(combo):
|
||
|
|
msg = 'test method is not defined: {0}, {1}'
|
||
|
|
raise AssertionError(msg.format(type(cls), combo))
|
||
|
|
|
||
|
|
yield
|
||
|
|
|
||
|
|
|
||
|
|
class CoercionBase(object):
|
||
|
|
|
||
|
|
klasses = ['index', 'series']
|
||
|
|
dtypes = ['object', 'int64', 'float64', 'complex128', 'bool',
|
||
|
|
'datetime64', 'datetime64tz', 'timedelta64', 'period']
|
||
|
|
|
||
|
|
@property
|
||
|
|
def method(self):
|
||
|
|
raise NotImplementedError(self)
|
||
|
|
|
||
|
|
def _assert(self, left, right, dtype):
|
||
|
|
# explicitly check dtype to avoid any unexpected result
|
||
|
|
if isinstance(left, pd.Series):
|
||
|
|
tm.assert_series_equal(left, right)
|
||
|
|
elif isinstance(left, pd.Index):
|
||
|
|
tm.assert_index_equal(left, right)
|
||
|
|
else:
|
||
|
|
raise NotImplementedError
|
||
|
|
assert left.dtype == dtype
|
||
|
|
assert right.dtype == dtype
|
||
|
|
|
||
|
|
|
||
|
|
class TestSetitemCoercion(CoercionBase):
|
||
|
|
|
||
|
|
method = 'setitem'
|
||
|
|
|
||
|
|
def _assert_setitem_series_conversion(self, original_series, loc_value,
|
||
|
|
expected_series, expected_dtype):
|
||
|
|
""" test series value's coercion triggered by assignment """
|
||
|
|
temp = original_series.copy()
|
||
|
|
temp[1] = loc_value
|
||
|
|
tm.assert_series_equal(temp, expected_series)
|
||
|
|
# check dtype explicitly for sure
|
||
|
|
assert temp.dtype == expected_dtype
|
||
|
|
|
||
|
|
# .loc works different rule, temporary disable
|
||
|
|
# temp = original_series.copy()
|
||
|
|
# temp.loc[1] = loc_value
|
||
|
|
# tm.assert_series_equal(temp, expected_series)
|
||
|
|
|
||
|
|
@pytest.mark.parametrize("val,exp_dtype", [
|
||
|
|
(1, np.object),
|
||
|
|
(1.1, np.object),
|
||
|
|
(1 + 1j, np.object),
|
||
|
|
(True, np.object)])
|
||
|
|
def test_setitem_series_object(self, val, exp_dtype):
|
||
|
|
obj = pd.Series(list('abcd'))
|
||
|
|
assert obj.dtype == np.object
|
||
|
|
|
||
|
|
exp = pd.Series(['a', val, 'c', 'd'])
|
||
|
|
self._assert_setitem_series_conversion(obj, val, exp, exp_dtype)
|
||
|
|
|
||
|
|
@pytest.mark.parametrize("val,exp_dtype", [
|
||
|
|
(1, np.int64),
|
||
|
|
(1.1, np.float64),
|
||
|
|
(1 + 1j, np.complex128),
|
||
|
|
(True, np.object)])
|
||
|
|
def test_setitem_series_int64(self, val, exp_dtype):
|
||
|
|
obj = pd.Series([1, 2, 3, 4])
|
||
|
|
assert obj.dtype == np.int64
|
||
|
|
|
||
|
|
if exp_dtype is np.float64:
|
||
|
|
exp = pd.Series([1, 1, 3, 4])
|
||
|
|
self._assert_setitem_series_conversion(obj, 1.1, exp, np.int64)
|
||
|
|
pytest.xfail("GH12747 The result must be float")
|
||
|
|
|
||
|
|
exp = pd.Series([1, val, 3, 4])
|
||
|
|
self._assert_setitem_series_conversion(obj, val, exp, exp_dtype)
|
||
|
|
|
||
|
|
@pytest.mark.parametrize("val,exp_dtype", [
|
||
|
|
(np.int32(1), np.int8),
|
||
|
|
(np.int16(2**9), np.int16)])
|
||
|
|
def test_setitem_series_int8(self, val, exp_dtype):
|
||
|
|
obj = pd.Series([1, 2, 3, 4], dtype=np.int8)
|
||
|
|
assert obj.dtype == np.int8
|
||
|
|
|
||
|
|
if exp_dtype is np.int16:
|
||
|
|
exp = pd.Series([1, 0, 3, 4], dtype=np.int8)
|
||
|
|
self._assert_setitem_series_conversion(obj, val, exp, np.int8)
|
||
|
|
pytest.xfail("BUG: it must be Series([1, 1, 3, 4], dtype=np.int16")
|
||
|
|
|
||
|
|
exp = pd.Series([1, val, 3, 4], dtype=np.int8)
|
||
|
|
self._assert_setitem_series_conversion(obj, val, exp, exp_dtype)
|
||
|
|
|
||
|
|
@pytest.mark.parametrize("val,exp_dtype", [
|
||
|
|
(1, np.float64),
|
||
|
|
(1.1, np.float64),
|
||
|
|
(1 + 1j, np.complex128),
|
||
|
|
(True, np.object)])
|
||
|
|
def test_setitem_series_float64(self, val, exp_dtype):
|
||
|
|
obj = pd.Series([1.1, 2.2, 3.3, 4.4])
|
||
|
|
assert obj.dtype == np.float64
|
||
|
|
|
||
|
|
exp = pd.Series([1.1, val, 3.3, 4.4])
|
||
|
|
self._assert_setitem_series_conversion(obj, val, exp, exp_dtype)
|
||
|
|
|
||
|
|
@pytest.mark.parametrize("val,exp_dtype", [
|
||
|
|
(1, np.complex128),
|
||
|
|
(1.1, np.complex128),
|
||
|
|
(1 + 1j, np.complex128),
|
||
|
|
(True, np.object)])
|
||
|
|
def test_setitem_series_complex128(self, val, exp_dtype):
|
||
|
|
obj = pd.Series([1 + 1j, 2 + 2j, 3 + 3j, 4 + 4j])
|
||
|
|
assert obj.dtype == np.complex128
|
||
|
|
|
||
|
|
exp = pd.Series([1 + 1j, val, 3 + 3j, 4 + 4j])
|
||
|
|
self._assert_setitem_series_conversion(obj, val, exp, exp_dtype)
|
||
|
|
|
||
|
|
@pytest.mark.parametrize("val,exp_dtype", [
|
||
|
|
(1, np.int64),
|
||
|
|
(3, np.int64),
|
||
|
|
(1.1, np.float64),
|
||
|
|
(1 + 1j, np.complex128),
|
||
|
|
(True, np.bool)])
|
||
|
|
def test_setitem_series_bool(self, val, exp_dtype):
|
||
|
|
obj = pd.Series([True, False, True, False])
|
||
|
|
assert obj.dtype == np.bool
|
||
|
|
|
||
|
|
if exp_dtype is np.int64:
|
||
|
|
exp = pd.Series([True, True, True, False])
|
||
|
|
self._assert_setitem_series_conversion(obj, val, exp, np.bool)
|
||
|
|
pytest.xfail("TODO_GH12747 The result must be int")
|
||
|
|
elif exp_dtype is np.float64:
|
||
|
|
exp = pd.Series([True, True, True, False])
|
||
|
|
self._assert_setitem_series_conversion(obj, val, exp, np.bool)
|
||
|
|
pytest.xfail("TODO_GH12747 The result must be float")
|
||
|
|
elif exp_dtype is np.complex128:
|
||
|
|
exp = pd.Series([True, True, True, False])
|
||
|
|
self._assert_setitem_series_conversion(obj, val, exp, np.bool)
|
||
|
|
pytest.xfail("TODO_GH12747 The result must be complex")
|
||
|
|
|
||
|
|
exp = pd.Series([True, val, True, False])
|
||
|
|
self._assert_setitem_series_conversion(obj, val, exp, exp_dtype)
|
||
|
|
|
||
|
|
@pytest.mark.parametrize("val,exp_dtype", [
|
||
|
|
(pd.Timestamp('2012-01-01'), 'datetime64[ns]'),
|
||
|
|
(1, np.object),
|
||
|
|
('x', np.object)])
|
||
|
|
def test_setitem_series_datetime64(self, val, exp_dtype):
|
||
|
|
obj = pd.Series([pd.Timestamp('2011-01-01'),
|
||
|
|
pd.Timestamp('2011-01-02'),
|
||
|
|
pd.Timestamp('2011-01-03'),
|
||
|
|
pd.Timestamp('2011-01-04')])
|
||
|
|
assert obj.dtype == 'datetime64[ns]'
|
||
|
|
|
||
|
|
exp = pd.Series([pd.Timestamp('2011-01-01'),
|
||
|
|
val,
|
||
|
|
pd.Timestamp('2011-01-03'),
|
||
|
|
pd.Timestamp('2011-01-04')])
|
||
|
|
self._assert_setitem_series_conversion(obj, val, exp, exp_dtype)
|
||
|
|
|
||
|
|
@pytest.mark.parametrize("val,exp_dtype", [
|
||
|
|
(pd.Timestamp('2012-01-01', tz='US/Eastern'),
|
||
|
|
'datetime64[ns, US/Eastern]'),
|
||
|
|
(pd.Timestamp('2012-01-01', tz='US/Pacific'), np.object),
|
||
|
|
(pd.Timestamp('2012-01-01'), np.object),
|
||
|
|
(1, np.object)])
|
||
|
|
def test_setitem_series_datetime64tz(self, val, exp_dtype):
|
||
|
|
tz = 'US/Eastern'
|
||
|
|
obj = pd.Series([pd.Timestamp('2011-01-01', tz=tz),
|
||
|
|
pd.Timestamp('2011-01-02', tz=tz),
|
||
|
|
pd.Timestamp('2011-01-03', tz=tz),
|
||
|
|
pd.Timestamp('2011-01-04', tz=tz)])
|
||
|
|
assert obj.dtype == 'datetime64[ns, US/Eastern]'
|
||
|
|
|
||
|
|
exp = pd.Series([pd.Timestamp('2011-01-01', tz=tz),
|
||
|
|
val,
|
||
|
|
pd.Timestamp('2011-01-03', tz=tz),
|
||
|
|
pd.Timestamp('2011-01-04', tz=tz)])
|
||
|
|
self._assert_setitem_series_conversion(obj, val, exp, exp_dtype)
|
||
|
|
|
||
|
|
@pytest.mark.parametrize("val,exp_dtype", [
|
||
|
|
(pd.Timedelta('12 day'), 'timedelta64[ns]'),
|
||
|
|
(1, np.object),
|
||
|
|
('x', np.object)])
|
||
|
|
def test_setitem_series_timedelta64(self, val, exp_dtype):
|
||
|
|
obj = pd.Series([pd.Timedelta('1 day'),
|
||
|
|
pd.Timedelta('2 day'),
|
||
|
|
pd.Timedelta('3 day'),
|
||
|
|
pd.Timedelta('4 day')])
|
||
|
|
assert obj.dtype == 'timedelta64[ns]'
|
||
|
|
|
||
|
|
exp = pd.Series([pd.Timedelta('1 day'),
|
||
|
|
val,
|
||
|
|
pd.Timedelta('3 day'),
|
||
|
|
pd.Timedelta('4 day')])
|
||
|
|
self._assert_setitem_series_conversion(obj, val, exp, exp_dtype)
|
||
|
|
|
||
|
|
def _assert_setitem_index_conversion(self, original_series, loc_key,
|
||
|
|
expected_index, expected_dtype):
|
||
|
|
""" test index's coercion triggered by assign key """
|
||
|
|
temp = original_series.copy()
|
||
|
|
temp[loc_key] = 5
|
||
|
|
exp = pd.Series([1, 2, 3, 4, 5], index=expected_index)
|
||
|
|
tm.assert_series_equal(temp, exp)
|
||
|
|
# check dtype explicitly for sure
|
||
|
|
assert temp.index.dtype == expected_dtype
|
||
|
|
|
||
|
|
temp = original_series.copy()
|
||
|
|
temp.loc[loc_key] = 5
|
||
|
|
exp = pd.Series([1, 2, 3, 4, 5], index=expected_index)
|
||
|
|
tm.assert_series_equal(temp, exp)
|
||
|
|
# check dtype explicitly for sure
|
||
|
|
assert temp.index.dtype == expected_dtype
|
||
|
|
|
||
|
|
@pytest.mark.parametrize("val,exp_dtype", [
|
||
|
|
('x', np.object),
|
||
|
|
(5, IndexError),
|
||
|
|
(1.1, np.object)])
|
||
|
|
def test_setitem_index_object(self, val, exp_dtype):
|
||
|
|
obj = pd.Series([1, 2, 3, 4], index=list('abcd'))
|
||
|
|
assert obj.index.dtype == np.object
|
||
|
|
|
||
|
|
if exp_dtype is IndexError:
|
||
|
|
temp = obj.copy()
|
||
|
|
with pytest.raises(exp_dtype):
|
||
|
|
temp[5] = 5
|
||
|
|
else:
|
||
|
|
exp_index = pd.Index(list('abcd') + [val])
|
||
|
|
self._assert_setitem_index_conversion(obj, val, exp_index,
|
||
|
|
exp_dtype)
|
||
|
|
|
||
|
|
@pytest.mark.parametrize("val,exp_dtype", [
|
||
|
|
(5, np.int64),
|
||
|
|
(1.1, np.float64),
|
||
|
|
('x', np.object)])
|
||
|
|
def test_setitem_index_int64(self, val, exp_dtype):
|
||
|
|
obj = pd.Series([1, 2, 3, 4])
|
||
|
|
assert obj.index.dtype == np.int64
|
||
|
|
|
||
|
|
exp_index = pd.Index([0, 1, 2, 3, val])
|
||
|
|
self._assert_setitem_index_conversion(obj, val, exp_index, exp_dtype)
|
||
|
|
|
||
|
|
@pytest.mark.parametrize("val,exp_dtype", [
|
||
|
|
(5, IndexError),
|
||
|
|
(5.1, np.float64),
|
||
|
|
('x', np.object)])
|
||
|
|
def test_setitem_index_float64(self, val, exp_dtype):
|
||
|
|
obj = pd.Series([1, 2, 3, 4], index=[1.1, 2.1, 3.1, 4.1])
|
||
|
|
assert obj.index.dtype == np.float64
|
||
|
|
|
||
|
|
if exp_dtype is IndexError:
|
||
|
|
# float + int -> int
|
||
|
|
temp = obj.copy()
|
||
|
|
with pytest.raises(exp_dtype):
|
||
|
|
temp[5] = 5
|
||
|
|
pytest.xfail("TODO_GH12747 The result must be float")
|
||
|
|
|
||
|
|
exp_index = pd.Index([1.1, 2.1, 3.1, 4.1, val])
|
||
|
|
self._assert_setitem_index_conversion(obj, val, exp_index, exp_dtype)
|
||
|
|
|
||
|
|
def test_setitem_series_period(self):
|
||
|
|
pass
|
||
|
|
|
||
|
|
def test_setitem_index_complex128(self):
|
||
|
|
pass
|
||
|
|
|
||
|
|
def test_setitem_index_bool(self):
|
||
|
|
pass
|
||
|
|
|
||
|
|
def test_setitem_index_datetime64(self):
|
||
|
|
pass
|
||
|
|
|
||
|
|
def test_setitem_index_datetime64tz(self):
|
||
|
|
pass
|
||
|
|
|
||
|
|
def test_setitem_index_timedelta64(self):
|
||
|
|
pass
|
||
|
|
|
||
|
|
def test_setitem_index_period(self):
|
||
|
|
pass
|
||
|
|
|
||
|
|
|
||
|
|
class TestInsertIndexCoercion(CoercionBase):
|
||
|
|
|
||
|
|
klasses = ['index']
|
||
|
|
method = 'insert'
|
||
|
|
|
||
|
|
def _assert_insert_conversion(self, original, value,
|
||
|
|
expected, expected_dtype):
|
||
|
|
""" test coercion triggered by insert """
|
||
|
|
target = original.copy()
|
||
|
|
res = target.insert(1, value)
|
||
|
|
tm.assert_index_equal(res, expected)
|
||
|
|
assert res.dtype == expected_dtype
|
||
|
|
|
||
|
|
@pytest.mark.parametrize("insert, coerced_val, coerced_dtype", [
|
||
|
|
(1, 1, np.object),
|
||
|
|
(1.1, 1.1, np.object),
|
||
|
|
(False, False, np.object),
|
||
|
|
('x', 'x', np.object)])
|
||
|
|
def test_insert_index_object(self, insert, coerced_val, coerced_dtype):
|
||
|
|
obj = pd.Index(list('abcd'))
|
||
|
|
assert obj.dtype == np.object
|
||
|
|
|
||
|
|
exp = pd.Index(['a', coerced_val, 'b', 'c', 'd'])
|
||
|
|
self._assert_insert_conversion(obj, insert, exp, coerced_dtype)
|
||
|
|
|
||
|
|
@pytest.mark.parametrize("insert, coerced_val, coerced_dtype", [
|
||
|
|
(1, 1, np.int64),
|
||
|
|
(1.1, 1.1, np.float64),
|
||
|
|
(False, 0, np.int64),
|
||
|
|
('x', 'x', np.object)])
|
||
|
|
def test_insert_index_int64(self, insert, coerced_val, coerced_dtype):
|
||
|
|
obj = pd.Int64Index([1, 2, 3, 4])
|
||
|
|
assert obj.dtype == np.int64
|
||
|
|
|
||
|
|
exp = pd.Index([1, coerced_val, 2, 3, 4])
|
||
|
|
self._assert_insert_conversion(obj, insert, exp, coerced_dtype)
|
||
|
|
|
||
|
|
@pytest.mark.parametrize("insert, coerced_val, coerced_dtype", [
|
||
|
|
(1, 1., np.float64),
|
||
|
|
(1.1, 1.1, np.float64),
|
||
|
|
(False, 0., np.float64),
|
||
|
|
('x', 'x', np.object)])
|
||
|
|
def test_insert_index_float64(self, insert, coerced_val, coerced_dtype):
|
||
|
|
obj = pd.Float64Index([1., 2., 3., 4.])
|
||
|
|
assert obj.dtype == np.float64
|
||
|
|
|
||
|
|
exp = pd.Index([1., coerced_val, 2., 3., 4.])
|
||
|
|
self._assert_insert_conversion(obj, insert, exp, coerced_dtype)
|
||
|
|
|
||
|
|
@pytest.mark.parametrize('fill_val,exp_dtype', [
|
||
|
|
(pd.Timestamp('2012-01-01'), 'datetime64[ns]'),
|
||
|
|
(pd.Timestamp('2012-01-01', tz='US/Eastern'),
|
||
|
|
'datetime64[ns, US/Eastern]')],
|
||
|
|
ids=['datetime64', 'datetime64tz'])
|
||
|
|
def test_insert_index_datetimes(self, fill_val, exp_dtype):
|
||
|
|
obj = pd.DatetimeIndex(['2011-01-01', '2011-01-02', '2011-01-03',
|
||
|
|
'2011-01-04'], tz=fill_val.tz)
|
||
|
|
assert obj.dtype == exp_dtype
|
||
|
|
|
||
|
|
exp = pd.DatetimeIndex(['2011-01-01', fill_val.date(), '2011-01-02',
|
||
|
|
'2011-01-03', '2011-01-04'], tz=fill_val.tz)
|
||
|
|
self._assert_insert_conversion(obj, fill_val, exp, exp_dtype)
|
||
|
|
|
||
|
|
msg = "Passed item and index have different timezone"
|
||
|
|
if fill_val.tz:
|
||
|
|
with tm.assert_raises_regex(ValueError, msg):
|
||
|
|
obj.insert(1, pd.Timestamp('2012-01-01'))
|
||
|
|
|
||
|
|
with tm.assert_raises_regex(ValueError, msg):
|
||
|
|
obj.insert(1, pd.Timestamp('2012-01-01', tz='Asia/Tokyo'))
|
||
|
|
|
||
|
|
msg = "cannot insert DatetimeIndex with incompatible label"
|
||
|
|
with tm.assert_raises_regex(TypeError, msg):
|
||
|
|
obj.insert(1, 1)
|
||
|
|
|
||
|
|
pytest.xfail("ToDo: must coerce to object")
|
||
|
|
|
||
|
|
def test_insert_index_timedelta64(self):
|
||
|
|
obj = pd.TimedeltaIndex(['1 day', '2 day', '3 day', '4 day'])
|
||
|
|
assert obj.dtype == 'timedelta64[ns]'
|
||
|
|
|
||
|
|
# timedelta64 + timedelta64 => timedelta64
|
||
|
|
exp = pd.TimedeltaIndex(['1 day', '10 day', '2 day', '3 day', '4 day'])
|
||
|
|
self._assert_insert_conversion(obj, pd.Timedelta('10 day'),
|
||
|
|
exp, 'timedelta64[ns]')
|
||
|
|
|
||
|
|
# ToDo: must coerce to object
|
||
|
|
msg = "cannot insert TimedeltaIndex with incompatible label"
|
||
|
|
with tm.assert_raises_regex(TypeError, msg):
|
||
|
|
obj.insert(1, pd.Timestamp('2012-01-01'))
|
||
|
|
|
||
|
|
# ToDo: must coerce to object
|
||
|
|
msg = "cannot insert TimedeltaIndex with incompatible label"
|
||
|
|
with tm.assert_raises_regex(TypeError, msg):
|
||
|
|
obj.insert(1, 1)
|
||
|
|
|
||
|
|
@pytest.mark.parametrize("insert, coerced_val, coerced_dtype", [
|
||
|
|
(pd.Period('2012-01', freq='M'), '2012-01', 'period[M]'),
|
||
|
|
(pd.Timestamp('2012-01-01'), pd.Timestamp('2012-01-01'), np.object),
|
||
|
|
(1, 1, np.object),
|
||
|
|
('x', 'x', np.object)])
|
||
|
|
def test_insert_index_period(self, insert, coerced_val, coerced_dtype):
|
||
|
|
obj = pd.PeriodIndex(['2011-01', '2011-02', '2011-03', '2011-04'],
|
||
|
|
freq='M')
|
||
|
|
assert obj.dtype == 'period[M]'
|
||
|
|
|
||
|
|
if isinstance(insert, pd.Period):
|
||
|
|
index_type = pd.PeriodIndex
|
||
|
|
else:
|
||
|
|
index_type = pd.Index
|
||
|
|
|
||
|
|
exp = index_type([pd.Period('2011-01', freq='M'),
|
||
|
|
coerced_val,
|
||
|
|
pd.Period('2011-02', freq='M'),
|
||
|
|
pd.Period('2011-03', freq='M'),
|
||
|
|
pd.Period('2011-04', freq='M')], freq='M')
|
||
|
|
self._assert_insert_conversion(obj, insert, exp, coerced_dtype)
|
||
|
|
|
||
|
|
def test_insert_index_complex128(self):
|
||
|
|
pass
|
||
|
|
|
||
|
|
def test_insert_index_bool(self):
|
||
|
|
pass
|
||
|
|
|
||
|
|
|
||
|
|
class TestWhereCoercion(CoercionBase):
|
||
|
|
|
||
|
|
method = 'where'
|
||
|
|
|
||
|
|
def _assert_where_conversion(self, original, cond, values,
|
||
|
|
expected, expected_dtype):
|
||
|
|
""" test coercion triggered by where """
|
||
|
|
target = original.copy()
|
||
|
|
res = target.where(cond, values)
|
||
|
|
self._assert(res, expected, expected_dtype)
|
||
|
|
|
||
|
|
@pytest.mark.parametrize("klass", [pd.Series, pd.Index],
|
||
|
|
ids=['series', 'index'])
|
||
|
|
@pytest.mark.parametrize("fill_val,exp_dtype", [
|
||
|
|
(1, np.object),
|
||
|
|
(1.1, np.object),
|
||
|
|
(1 + 1j, np.object),
|
||
|
|
(True, np.object)])
|
||
|
|
def test_where_object(self, klass, fill_val, exp_dtype):
|
||
|
|
obj = klass(list('abcd'))
|
||
|
|
assert obj.dtype == np.object
|
||
|
|
cond = klass([True, False, True, False])
|
||
|
|
|
||
|
|
if fill_val is True and klass is pd.Series:
|
||
|
|
ret_val = 1
|
||
|
|
else:
|
||
|
|
ret_val = fill_val
|
||
|
|
|
||
|
|
exp = klass(['a', ret_val, 'c', ret_val])
|
||
|
|
self._assert_where_conversion(obj, cond, fill_val, exp, exp_dtype)
|
||
|
|
|
||
|
|
if fill_val is True:
|
||
|
|
values = klass([True, False, True, True])
|
||
|
|
else:
|
||
|
|
values = klass(fill_val * x for x in [5, 6, 7, 8])
|
||
|
|
|
||
|
|
exp = klass(['a', values[1], 'c', values[3]])
|
||
|
|
self._assert_where_conversion(obj, cond, values, exp, exp_dtype)
|
||
|
|
|
||
|
|
@pytest.mark.parametrize("klass", [pd.Series, pd.Index],
|
||
|
|
ids=['series', 'index'])
|
||
|
|
@pytest.mark.parametrize("fill_val,exp_dtype", [
|
||
|
|
(1, np.int64),
|
||
|
|
(1.1, np.float64),
|
||
|
|
(1 + 1j, np.complex128),
|
||
|
|
(True, np.object)])
|
||
|
|
def test_where_int64(self, klass, fill_val, exp_dtype):
|
||
|
|
if klass is pd.Index and exp_dtype is np.complex128:
|
||
|
|
pytest.skip("Complex Index not supported")
|
||
|
|
obj = klass([1, 2, 3, 4])
|
||
|
|
assert obj.dtype == np.int64
|
||
|
|
cond = klass([True, False, True, False])
|
||
|
|
|
||
|
|
exp = klass([1, fill_val, 3, fill_val])
|
||
|
|
self._assert_where_conversion(obj, cond, fill_val, exp, exp_dtype)
|
||
|
|
|
||
|
|
if fill_val is True:
|
||
|
|
values = klass([True, False, True, True])
|
||
|
|
else:
|
||
|
|
values = klass(x * fill_val for x in [5, 6, 7, 8])
|
||
|
|
exp = klass([1, values[1], 3, values[3]])
|
||
|
|
self._assert_where_conversion(obj, cond, values, exp, exp_dtype)
|
||
|
|
|
||
|
|
@pytest.mark.parametrize("klass", [pd.Series, pd.Index],
|
||
|
|
ids=['series', 'index'])
|
||
|
|
@pytest.mark.parametrize("fill_val, exp_dtype", [
|
||
|
|
(1, np.float64),
|
||
|
|
(1.1, np.float64),
|
||
|
|
(1 + 1j, np.complex128),
|
||
|
|
(True, np.object)])
|
||
|
|
def test_where_float64(self, klass, fill_val, exp_dtype):
|
||
|
|
if klass is pd.Index and exp_dtype is np.complex128:
|
||
|
|
pytest.skip("Complex Index not supported")
|
||
|
|
obj = klass([1.1, 2.2, 3.3, 4.4])
|
||
|
|
assert obj.dtype == np.float64
|
||
|
|
cond = klass([True, False, True, False])
|
||
|
|
|
||
|
|
exp = klass([1.1, fill_val, 3.3, fill_val])
|
||
|
|
self._assert_where_conversion(obj, cond, fill_val, exp, exp_dtype)
|
||
|
|
|
||
|
|
if fill_val is True:
|
||
|
|
values = klass([True, False, True, True])
|
||
|
|
else:
|
||
|
|
values = klass(x * fill_val for x in [5, 6, 7, 8])
|
||
|
|
exp = klass([1.1, values[1], 3.3, values[3]])
|
||
|
|
self._assert_where_conversion(obj, cond, values, exp, exp_dtype)
|
||
|
|
|
||
|
|
@pytest.mark.parametrize("fill_val,exp_dtype", [
|
||
|
|
(1, np.complex128),
|
||
|
|
(1.1, np.complex128),
|
||
|
|
(1 + 1j, np.complex128),
|
||
|
|
(True, np.object)])
|
||
|
|
def test_where_series_complex128(self, fill_val, exp_dtype):
|
||
|
|
obj = pd.Series([1 + 1j, 2 + 2j, 3 + 3j, 4 + 4j])
|
||
|
|
assert obj.dtype == np.complex128
|
||
|
|
cond = pd.Series([True, False, True, False])
|
||
|
|
|
||
|
|
exp = pd.Series([1 + 1j, fill_val, 3 + 3j, fill_val])
|
||
|
|
self._assert_where_conversion(obj, cond, fill_val, exp, exp_dtype)
|
||
|
|
|
||
|
|
if fill_val is True:
|
||
|
|
values = pd.Series([True, False, True, True])
|
||
|
|
else:
|
||
|
|
values = pd.Series(x * fill_val for x in [5, 6, 7, 8])
|
||
|
|
exp = pd.Series([1 + 1j, values[1], 3 + 3j, values[3]])
|
||
|
|
self._assert_where_conversion(obj, cond, values, exp, exp_dtype)
|
||
|
|
|
||
|
|
@pytest.mark.parametrize("fill_val,exp_dtype", [
|
||
|
|
(1, np.object),
|
||
|
|
(1.1, np.object),
|
||
|
|
(1 + 1j, np.object),
|
||
|
|
(True, np.bool)])
|
||
|
|
def test_where_series_bool(self, fill_val, exp_dtype):
|
||
|
|
|
||
|
|
obj = pd.Series([True, False, True, False])
|
||
|
|
assert obj.dtype == np.bool
|
||
|
|
cond = pd.Series([True, False, True, False])
|
||
|
|
|
||
|
|
exp = pd.Series([True, fill_val, True, fill_val])
|
||
|
|
self._assert_where_conversion(obj, cond, fill_val, exp, exp_dtype)
|
||
|
|
|
||
|
|
if fill_val is True:
|
||
|
|
values = pd.Series([True, False, True, True])
|
||
|
|
else:
|
||
|
|
values = pd.Series(x * fill_val for x in [5, 6, 7, 8])
|
||
|
|
exp = pd.Series([True, values[1], True, values[3]])
|
||
|
|
self._assert_where_conversion(obj, cond, values, exp, exp_dtype)
|
||
|
|
|
||
|
|
@pytest.mark.parametrize("fill_val,exp_dtype", [
|
||
|
|
(pd.Timestamp('2012-01-01'), 'datetime64[ns]'),
|
||
|
|
(pd.Timestamp('2012-01-01', tz='US/Eastern'), np.object)],
|
||
|
|
ids=['datetime64', 'datetime64tz'])
|
||
|
|
def test_where_series_datetime64(self, fill_val, exp_dtype):
|
||
|
|
obj = pd.Series([pd.Timestamp('2011-01-01'),
|
||
|
|
pd.Timestamp('2011-01-02'),
|
||
|
|
pd.Timestamp('2011-01-03'),
|
||
|
|
pd.Timestamp('2011-01-04')])
|
||
|
|
assert obj.dtype == 'datetime64[ns]'
|
||
|
|
cond = pd.Series([True, False, True, False])
|
||
|
|
|
||
|
|
exp = pd.Series([pd.Timestamp('2011-01-01'), fill_val,
|
||
|
|
pd.Timestamp('2011-01-03'), fill_val])
|
||
|
|
self._assert_where_conversion(obj, cond, fill_val, exp, exp_dtype)
|
||
|
|
|
||
|
|
values = pd.Series(pd.date_range(fill_val, periods=4))
|
||
|
|
if fill_val.tz:
|
||
|
|
exp = pd.Series([pd.Timestamp('2011-01-01'),
|
||
|
|
pd.Timestamp('2012-01-02 05:00'),
|
||
|
|
pd.Timestamp('2011-01-03'),
|
||
|
|
pd.Timestamp('2012-01-04 05:00')])
|
||
|
|
self._assert_where_conversion(obj, cond, values, exp,
|
||
|
|
'datetime64[ns]')
|
||
|
|
pytest.xfail("ToDo: do not coerce to UTC, must be object")
|
||
|
|
|
||
|
|
exp = pd.Series([pd.Timestamp('2011-01-01'), values[1],
|
||
|
|
pd.Timestamp('2011-01-03'), values[3]])
|
||
|
|
self._assert_where_conversion(obj, cond, values, exp, exp_dtype)
|
||
|
|
|
||
|
|
@pytest.mark.parametrize("fill_val,exp_dtype", [
|
||
|
|
(pd.Timestamp('2012-01-01'), 'datetime64[ns]'),
|
||
|
|
(pd.Timestamp('2012-01-01', tz='US/Eastern'), np.object)],
|
||
|
|
ids=['datetime64', 'datetime64tz'])
|
||
|
|
def test_where_index_datetime(self, fill_val, exp_dtype):
|
||
|
|
obj = pd.Index([pd.Timestamp('2011-01-01'),
|
||
|
|
pd.Timestamp('2011-01-02'),
|
||
|
|
pd.Timestamp('2011-01-03'),
|
||
|
|
pd.Timestamp('2011-01-04')])
|
||
|
|
assert obj.dtype == 'datetime64[ns]'
|
||
|
|
cond = pd.Index([True, False, True, False])
|
||
|
|
|
||
|
|
msg = ("Index\\(\\.\\.\\.\\) must be called with a collection "
|
||
|
|
"of some kind")
|
||
|
|
with tm.assert_raises_regex(TypeError, msg):
|
||
|
|
obj.where(cond, fill_val)
|
||
|
|
|
||
|
|
values = pd.Index(pd.date_range(fill_val, periods=4))
|
||
|
|
exp = pd.Index([pd.Timestamp('2011-01-01'),
|
||
|
|
pd.Timestamp('2012-01-02'),
|
||
|
|
pd.Timestamp('2011-01-03'),
|
||
|
|
pd.Timestamp('2012-01-04')])
|
||
|
|
|
||
|
|
if fill_val.tz:
|
||
|
|
self._assert_where_conversion(obj, cond, values, exp,
|
||
|
|
'datetime64[ns]')
|
||
|
|
pytest.xfail("ToDo: do not ignore timezone, must be object")
|
||
|
|
self._assert_where_conversion(obj, cond, values, exp, exp_dtype)
|
||
|
|
pytest.xfail("datetime64 + datetime64 -> datetime64 must support"
|
||
|
|
" scalar")
|
||
|
|
|
||
|
|
def test_where_index_complex128(self):
|
||
|
|
pass
|
||
|
|
|
||
|
|
def test_where_index_bool(self):
|
||
|
|
pass
|
||
|
|
|
||
|
|
def test_where_series_datetime64tz(self):
|
||
|
|
pass
|
||
|
|
|
||
|
|
def test_where_series_timedelta64(self):
|
||
|
|
pass
|
||
|
|
|
||
|
|
def test_where_series_period(self):
|
||
|
|
pass
|
||
|
|
|
||
|
|
def test_where_index_datetime64tz(self):
|
||
|
|
pass
|
||
|
|
|
||
|
|
def test_where_index_timedelta64(self):
|
||
|
|
pass
|
||
|
|
|
||
|
|
def test_where_index_period(self):
|
||
|
|
pass
|
||
|
|
|
||
|
|
|
||
|
|
class TestFillnaSeriesCoercion(CoercionBase):
|
||
|
|
|
||
|
|
# not indexing, but place here for consisntency
|
||
|
|
|
||
|
|
method = 'fillna'
|
||
|
|
|
||
|
|
def test_has_comprehensive_tests(self):
|
||
|
|
pass
|
||
|
|
|
||
|
|
def _assert_fillna_conversion(self, original, value,
|
||
|
|
expected, expected_dtype):
|
||
|
|
""" test coercion triggered by fillna """
|
||
|
|
target = original.copy()
|
||
|
|
res = target.fillna(value)
|
||
|
|
self._assert(res, expected, expected_dtype)
|
||
|
|
|
||
|
|
@pytest.mark.parametrize("klass", [pd.Series, pd.Index],
|
||
|
|
ids=['series', 'index'])
|
||
|
|
@pytest.mark.parametrize("fill_val, fill_dtype", [
|
||
|
|
(1, np.object),
|
||
|
|
(1.1, np.object),
|
||
|
|
(1 + 1j, np.object),
|
||
|
|
(True, np.object)])
|
||
|
|
def test_fillna_object(self, klass, fill_val, fill_dtype):
|
||
|
|
obj = klass(['a', np.nan, 'c', 'd'])
|
||
|
|
assert obj.dtype == np.object
|
||
|
|
|
||
|
|
exp = klass(['a', fill_val, 'c', 'd'])
|
||
|
|
self._assert_fillna_conversion(obj, fill_val, exp, fill_dtype)
|
||
|
|
|
||
|
|
@pytest.mark.parametrize("klass", [pd.Series, pd.Index],
|
||
|
|
ids=['series', 'index'])
|
||
|
|
@pytest.mark.parametrize("fill_val,fill_dtype", [
|
||
|
|
(1, np.float64),
|
||
|
|
(1.1, np.float64),
|
||
|
|
(1 + 1j, np.complex128),
|
||
|
|
(True, np.object)])
|
||
|
|
def test_fillna_float64(self, klass, fill_val, fill_dtype):
|
||
|
|
obj = klass([1.1, np.nan, 3.3, 4.4])
|
||
|
|
assert obj.dtype == np.float64
|
||
|
|
|
||
|
|
exp = klass([1.1, fill_val, 3.3, 4.4])
|
||
|
|
# float + complex -> we don't support a complex Index
|
||
|
|
# complex for Series,
|
||
|
|
# object for Index
|
||
|
|
if fill_dtype == np.complex128 and klass == pd.Index:
|
||
|
|
fill_dtype = np.object
|
||
|
|
self._assert_fillna_conversion(obj, fill_val, exp, fill_dtype)
|
||
|
|
|
||
|
|
@pytest.mark.parametrize("fill_val,fill_dtype", [
|
||
|
|
(1, np.complex128),
|
||
|
|
(1.1, np.complex128),
|
||
|
|
(1 + 1j, np.complex128),
|
||
|
|
(True, np.object)])
|
||
|
|
def test_fillna_series_complex128(self, fill_val, fill_dtype):
|
||
|
|
obj = pd.Series([1 + 1j, np.nan, 3 + 3j, 4 + 4j])
|
||
|
|
assert obj.dtype == np.complex128
|
||
|
|
|
||
|
|
exp = pd.Series([1 + 1j, fill_val, 3 + 3j, 4 + 4j])
|
||
|
|
self._assert_fillna_conversion(obj, fill_val, exp, fill_dtype)
|
||
|
|
|
||
|
|
@pytest.mark.parametrize("klass", [pd.Series, pd.Index],
|
||
|
|
ids=['series', 'index'])
|
||
|
|
@pytest.mark.parametrize("fill_val,fill_dtype", [
|
||
|
|
(pd.Timestamp('2012-01-01'), 'datetime64[ns]'),
|
||
|
|
(pd.Timestamp('2012-01-01', tz='US/Eastern'), np.object),
|
||
|
|
(1, np.object), ('x', np.object)],
|
||
|
|
ids=['datetime64', 'datetime64tz', 'object', 'object'])
|
||
|
|
def test_fillna_datetime(self, klass, fill_val, fill_dtype):
|
||
|
|
obj = klass([pd.Timestamp('2011-01-01'),
|
||
|
|
pd.NaT,
|
||
|
|
pd.Timestamp('2011-01-03'),
|
||
|
|
pd.Timestamp('2011-01-04')])
|
||
|
|
assert obj.dtype == 'datetime64[ns]'
|
||
|
|
|
||
|
|
exp = klass([pd.Timestamp('2011-01-01'),
|
||
|
|
fill_val,
|
||
|
|
pd.Timestamp('2011-01-03'),
|
||
|
|
pd.Timestamp('2011-01-04')])
|
||
|
|
self._assert_fillna_conversion(obj, fill_val, exp, fill_dtype)
|
||
|
|
|
||
|
|
@pytest.mark.parametrize("klass", [pd.Series, pd.Index])
|
||
|
|
@pytest.mark.parametrize("fill_val,fill_dtype", [
|
||
|
|
(pd.Timestamp('2012-01-01', tz='US/Eastern'),
|
||
|
|
'datetime64[ns, US/Eastern]'),
|
||
|
|
(pd.Timestamp('2012-01-01'), np.object),
|
||
|
|
(pd.Timestamp('2012-01-01', tz='Asia/Tokyo'), np.object),
|
||
|
|
(1, np.object),
|
||
|
|
('x', np.object)])
|
||
|
|
def test_fillna_datetime64tz(self, klass, fill_val, fill_dtype):
|
||
|
|
tz = 'US/Eastern'
|
||
|
|
|
||
|
|
obj = klass([pd.Timestamp('2011-01-01', tz=tz),
|
||
|
|
pd.NaT,
|
||
|
|
pd.Timestamp('2011-01-03', tz=tz),
|
||
|
|
pd.Timestamp('2011-01-04', tz=tz)])
|
||
|
|
assert obj.dtype == 'datetime64[ns, US/Eastern]'
|
||
|
|
|
||
|
|
exp = klass([pd.Timestamp('2011-01-01', tz=tz),
|
||
|
|
fill_val,
|
||
|
|
pd.Timestamp('2011-01-03', tz=tz),
|
||
|
|
pd.Timestamp('2011-01-04', tz=tz)])
|
||
|
|
self._assert_fillna_conversion(obj, fill_val, exp, fill_dtype)
|
||
|
|
|
||
|
|
def test_fillna_series_int64(self):
|
||
|
|
pass
|
||
|
|
|
||
|
|
def test_fillna_index_int64(self):
|
||
|
|
pass
|
||
|
|
|
||
|
|
def test_fillna_series_bool(self):
|
||
|
|
pass
|
||
|
|
|
||
|
|
def test_fillna_index_bool(self):
|
||
|
|
pass
|
||
|
|
|
||
|
|
def test_fillna_series_timedelta64(self):
|
||
|
|
pass
|
||
|
|
|
||
|
|
def test_fillna_series_period(self):
|
||
|
|
pass
|
||
|
|
|
||
|
|
def test_fillna_index_timedelta64(self):
|
||
|
|
pass
|
||
|
|
|
||
|
|
def test_fillna_index_period(self):
|
||
|
|
pass
|
||
|
|
|
||
|
|
|
||
|
|
class TestReplaceSeriesCoercion(CoercionBase):
|
||
|
|
|
||
|
|
klasses = ['series']
|
||
|
|
method = 'replace'
|
||
|
|
|
||
|
|
rep = {}
|
||
|
|
rep['object'] = ['a', 'b']
|
||
|
|
rep['int64'] = [4, 5]
|
||
|
|
rep['float64'] = [1.1, 2.2]
|
||
|
|
rep['complex128'] = [1 + 1j, 2 + 2j]
|
||
|
|
rep['bool'] = [True, False]
|
||
|
|
rep['datetime64[ns]'] = [pd.Timestamp('2011-01-01'),
|
||
|
|
pd.Timestamp('2011-01-03')]
|
||
|
|
|
||
|
|
for tz in ['UTC', 'US/Eastern']:
|
||
|
|
# to test tz => different tz replacement
|
||
|
|
key = 'datetime64[ns, {0}]'.format(tz)
|
||
|
|
rep[key] = [pd.Timestamp('2011-01-01', tz=tz),
|
||
|
|
pd.Timestamp('2011-01-03', tz=tz)]
|
||
|
|
|
||
|
|
rep['timedelta64[ns]'] = [pd.Timedelta('1 day'),
|
||
|
|
pd.Timedelta('2 day')]
|
||
|
|
|
||
|
|
@pytest.mark.parametrize('how', ['dict', 'series'])
|
||
|
|
@pytest.mark.parametrize('to_key', [
|
||
|
|
'object', 'int64', 'float64', 'complex128', 'bool', 'datetime64[ns]',
|
||
|
|
'datetime64[ns, UTC]', 'datetime64[ns, US/Eastern]', 'timedelta64[ns]'
|
||
|
|
], ids=['object', 'int64', 'float64', 'complex128', 'bool',
|
||
|
|
'datetime64', 'datetime64tz', 'datetime64tz', 'timedelta64'])
|
||
|
|
@pytest.mark.parametrize('from_key', [
|
||
|
|
'object', 'int64', 'float64', 'complex128', 'bool', 'datetime64[ns]',
|
||
|
|
'datetime64[ns, UTC]', 'datetime64[ns, US/Eastern]', 'timedelta64[ns]']
|
||
|
|
)
|
||
|
|
def test_replace_series(self, how, to_key, from_key):
|
||
|
|
if from_key == 'bool' and how == 'series' and compat.PY3:
|
||
|
|
# doesn't work in PY3, though ...dict_from_bool works fine
|
||
|
|
pytest.skip("doesn't work as in PY3")
|
||
|
|
|
||
|
|
index = pd.Index([3, 4], name='xxx')
|
||
|
|
obj = pd.Series(self.rep[from_key], index=index, name='yyy')
|
||
|
|
assert obj.dtype == from_key
|
||
|
|
|
||
|
|
if (from_key.startswith('datetime') and to_key.startswith('datetime')):
|
||
|
|
# tested below
|
||
|
|
return
|
||
|
|
elif from_key in ['datetime64[ns, US/Eastern]', 'datetime64[ns, UTC]']:
|
||
|
|
# tested below
|
||
|
|
return
|
||
|
|
|
||
|
|
if how == 'dict':
|
||
|
|
replacer = dict(zip(self.rep[from_key], self.rep[to_key]))
|
||
|
|
elif how == 'series':
|
||
|
|
replacer = pd.Series(self.rep[to_key], index=self.rep[from_key])
|
||
|
|
else:
|
||
|
|
raise ValueError
|
||
|
|
|
||
|
|
result = obj.replace(replacer)
|
||
|
|
|
||
|
|
if ((from_key == 'float64' and to_key in ('int64')) or
|
||
|
|
(from_key == 'complex128' and
|
||
|
|
to_key in ('int64', 'float64'))):
|
||
|
|
|
||
|
|
if compat.is_platform_32bit() or compat.is_platform_windows():
|
||
|
|
pytest.skip("32-bit platform buggy: {0} -> {1}".format
|
||
|
|
(from_key, to_key))
|
||
|
|
|
||
|
|
# Expected: do not downcast by replacement
|
||
|
|
exp = pd.Series(self.rep[to_key], index=index,
|
||
|
|
name='yyy', dtype=from_key)
|
||
|
|
|
||
|
|
else:
|
||
|
|
exp = pd.Series(self.rep[to_key], index=index, name='yyy')
|
||
|
|
assert exp.dtype == to_key
|
||
|
|
|
||
|
|
tm.assert_series_equal(result, exp)
|
||
|
|
|
||
|
|
# TODO(jbrockmendel) commented out to only have a single xfail printed
|
||
|
|
@pytest.mark.xfail(reason='GH #18376, tzawareness-compat bug '
|
||
|
|
'in BlockManager.replace_list')
|
||
|
|
# @pytest.mark.parametrize('how', ['dict', 'series'])
|
||
|
|
# @pytest.mark.parametrize('to_key', ['timedelta64[ns]', 'bool', 'object',
|
||
|
|
# 'complex128', 'float64', 'int64'])
|
||
|
|
# @pytest.mark.parametrize('from_key', ['datetime64[ns, UTC]',
|
||
|
|
# 'datetime64[ns, US/Eastern]'])
|
||
|
|
# def test_replace_series_datetime_tz(self, how, to_key, from_key):
|
||
|
|
def test_replace_series_datetime_tz(self):
|
||
|
|
how = 'series'
|
||
|
|
from_key = 'datetime64[ns, US/Eastern]'
|
||
|
|
to_key = 'timedelta64[ns]'
|
||
|
|
|
||
|
|
index = pd.Index([3, 4], name='xxx')
|
||
|
|
obj = pd.Series(self.rep[from_key], index=index, name='yyy')
|
||
|
|
assert obj.dtype == from_key
|
||
|
|
|
||
|
|
if how == 'dict':
|
||
|
|
replacer = dict(zip(self.rep[from_key], self.rep[to_key]))
|
||
|
|
elif how == 'series':
|
||
|
|
replacer = pd.Series(self.rep[to_key], index=self.rep[from_key])
|
||
|
|
else:
|
||
|
|
raise ValueError
|
||
|
|
|
||
|
|
result = obj.replace(replacer)
|
||
|
|
exp = pd.Series(self.rep[to_key], index=index, name='yyy')
|
||
|
|
assert exp.dtype == to_key
|
||
|
|
|
||
|
|
tm.assert_series_equal(result, exp)
|
||
|
|
|
||
|
|
# TODO(jreback) commented out to only have a single xfail printed
|
||
|
|
@pytest.mark.xfail(reason="different tz, "
|
||
|
|
"currently mask_missing raises SystemError")
|
||
|
|
# @pytest.mark.parametrize('how', ['dict', 'series'])
|
||
|
|
# @pytest.mark.parametrize('to_key', [
|
||
|
|
# 'datetime64[ns]', 'datetime64[ns, UTC]',
|
||
|
|
# 'datetime64[ns, US/Eastern]'])
|
||
|
|
# @pytest.mark.parametrize('from_key', [
|
||
|
|
# 'datetime64[ns]', 'datetime64[ns, UTC]',
|
||
|
|
# 'datetime64[ns, US/Eastern]'])
|
||
|
|
# def test_replace_series_datetime_datetime(self, how, to_key, from_key):
|
||
|
|
def test_replace_series_datetime_datetime(self):
|
||
|
|
how = 'dict'
|
||
|
|
to_key = 'datetime64[ns]'
|
||
|
|
from_key = 'datetime64[ns]'
|
||
|
|
|
||
|
|
index = pd.Index([3, 4], name='xxx')
|
||
|
|
obj = pd.Series(self.rep[from_key], index=index, name='yyy')
|
||
|
|
assert obj.dtype == from_key
|
||
|
|
|
||
|
|
if how == 'dict':
|
||
|
|
replacer = dict(zip(self.rep[from_key], self.rep[to_key]))
|
||
|
|
elif how == 'series':
|
||
|
|
replacer = pd.Series(self.rep[to_key], index=self.rep[from_key])
|
||
|
|
else:
|
||
|
|
raise ValueError
|
||
|
|
|
||
|
|
result = obj.replace(replacer)
|
||
|
|
exp = pd.Series(self.rep[to_key], index=index, name='yyy')
|
||
|
|
assert exp.dtype == to_key
|
||
|
|
|
||
|
|
tm.assert_series_equal(result, exp)
|
||
|
|
|
||
|
|
def test_replace_series_period(self):
|
||
|
|
pass
|