def test_astype_uint(self):
arr = timedelta_range("1H", periods=2)
expected = UInt64Index(
np.array([3600000000000, 90000000000000], dtype="uint64"))
with tm.assert_produces_warning(FutureWarning):
tm.assert_index_equal(arr.astype("uint64"), expected)
tm.assert_index_equal(arr.astype("uint32"), expected)
def test_astype_uint(self):
arr = date_range("2000", periods=2, name="idx")
expected = UInt64Index(
np.array([946684800000000000, 946771200000000000], dtype="uint64"),
name="idx",
)
tm.assert_index_equal(arr.astype("uint64"), expected)
tm.assert_index_equal(arr.astype("uint32"), expected)
def test_astype_uint(self):
arr = timedelta_range("1H", periods=2)
expected = UInt64Index(
np.array([3600000000000, 90000000000000], dtype="uint64"))
tm.assert_index_equal(arr.astype("uint64"), expected)
msg = "will return exactly the specified dtype instead of uint64"
with tm.assert_produces_warning(FutureWarning, match=msg):
res = arr.astype("uint32")
tm.assert_index_equal(res, expected)
def test_astype_uint(self):
arr = date_range("2000", periods=2, name="idx")
expected = UInt64Index(
np.array([946684800000000000, 946771200000000000], dtype="uint64"),
name="idx",
)
tm.assert_index_equal(arr.astype("uint64"), expected)
msg = "will return exactly the specified dtype instead of uint64"
with tm.assert_produces_warning(FutureWarning, match=msg):
res = arr.astype("uint32")
tm.assert_index_equal(res, expected)
def test_contains_with_float_index(self):
# GH#22085
integer_index = Int64Index([0, 1, 2, 3])
uinteger_index = UInt64Index([0, 1, 2, 3])
float_index = Float64Index([0.1, 1.1, 2.2, 3.3])
for index in (integer_index, uinteger_index):
assert 1.1 not in index
assert 1.0 in index
assert 1 in index
assert 1.1 in float_index
assert 1.0 not in float_index
assert 1 not in float_index
def makeUIntIndex(k=10, name=None):
base_idx = makeNumericIndex(k, name=name, dtype="uint64")
return UInt64Index(base_idx)
def test_astype_column_metadata(self, dtype):
# GH#19920
columns = UInt64Index([100, 200, 300], name="foo")
df = DataFrame(np.arange(15).reshape(5, 3), columns=columns)
df = df.astype(dtype)
tm.assert_index_equal(df.columns, columns)
class TestContains:
@pytest.mark.parametrize(
"index,val",
[
(Index([0, 1, 2]), 2),
(Index([0, 1, "2"]), "2"),
(Index([0, 1, 2, np.inf, 4]), 4),
(Index([0, 1, 2, np.nan, 4]), 4),
(Index([0, 1, 2, np.inf]), np.inf),
(Index([0, 1, 2, np.nan]), np.nan),
],
)
def test_index_contains(self, index, val):
assert val in index
@pytest.mark.parametrize(
"index,val",
[
(Index([0, 1, 2]), "2"),
(Index([0, 1, "2"]), 2),
(Index([0, 1, 2, np.inf]), 4),
(Index([0, 1, 2, np.nan]), 4),
(Index([0, 1, 2, np.inf]), np.nan),
(Index([0, 1, 2, np.nan]), np.inf),
# Checking if np.inf in Int64Index should not cause an OverflowError
# Related to GH 16957
(Int64Index([0, 1, 2]), np.inf),
(Int64Index([0, 1, 2]), np.nan),
(UInt64Index([0, 1, 2]), np.inf),
(UInt64Index([0, 1, 2]), np.nan),
],
)
def test_index_not_contains(self, index, val):
assert val not in index
@pytest.mark.parametrize("index,val", [(Index([0, 1, "2"]), 0),
(Index([0, 1, "2"]), "2")])
def test_mixed_index_contains(self, index, val):
# GH#19860
assert val in index
@pytest.mark.parametrize("index,val", [(Index([0, 1, "2"]), "1"),
(Index([0, 1, "2"]), 2)])
def test_mixed_index_not_contains(self, index, val):
# GH#19860
assert val not in index
def test_contains_with_float_index(self):
# GH#22085
integer_index = Int64Index([0, 1, 2, 3])
uinteger_index = UInt64Index([0, 1, 2, 3])
float_index = Float64Index([0.1, 1.1, 2.2, 3.3])
for index in (integer_index, uinteger_index):
assert 1.1 not in index
assert 1.0 in index
assert 1 in index
assert 1.1 in float_index
assert 1.0 not in float_index
assert 1 not in float_index
def test_contains_requires_hashable_raises(self, index):
if isinstance(index, MultiIndex):
return # TODO: do we want this to raise?
msg = "unhashable type: 'list'"
with pytest.raises(TypeError, match=msg):
[] in index
msg = "|".join([
r"unhashable type: 'dict'",
r"must be real number, not dict",
r"an integer is required",
r"\{\}",
r"pandas\._libs\.interval\.IntervalTree' is not iterable",
])
with pytest.raises(TypeError, match=msg):
{} in index._engine
class TestABCClasses:
tuples = [[1, 2, 2], ["red", "blue", "red"]]
multi_index = pd.MultiIndex.from_arrays(tuples, names=("number", "color"))
datetime_index = pd.to_datetime(["2000/1/1", "2010/1/1"])
timedelta_index = pd.to_timedelta(np.arange(5), unit="s")
period_index = pd.period_range("2000/1/1", "2010/1/1/", freq="M")
categorical = pd.Categorical([1, 2, 3], categories=[2, 3, 1])
categorical_df = pd.DataFrame({"values": [1, 2, 3]}, index=categorical)
df = pd.DataFrame({"names": ["a", "b", "c"]}, index=multi_index)
sparse_array = pd.arrays.SparseArray(np.random.randn(10))
datetime_array = pd.core.arrays.DatetimeArray(datetime_index)
timedelta_array = pd.core.arrays.TimedeltaArray(timedelta_index)
abc_pairs = [
("ABCInt64Index", Int64Index([1, 2, 3])),
("ABCUInt64Index", UInt64Index([1, 2, 3])),
("ABCFloat64Index", Float64Index([1, 2, 3])),
("ABCMultiIndex", multi_index),
("ABCDatetimeIndex", datetime_index),
("ABCRangeIndex", pd.RangeIndex(3)),
("ABCTimedeltaIndex", timedelta_index),
("ABCIntervalIndex", pd.interval_range(start=0, end=3)),
("ABCPeriodArray", pd.arrays.PeriodArray([2000, 2001, 2002], freq="D")),
("ABCPandasArray", pd.arrays.PandasArray(np.array([0, 1, 2]))),
("ABCPeriodIndex", period_index),
("ABCCategoricalIndex", categorical_df.index),
("ABCSeries", pd.Series([1, 2, 3])),
("ABCDataFrame", df),
("ABCCategorical", categorical),
("ABCDatetimeArray", datetime_array),
("ABCTimedeltaArray", timedelta_array),
]
@pytest.mark.parametrize("abctype1, inst", abc_pairs)
@pytest.mark.parametrize("abctype2, _", abc_pairs)
def test_abc_pairs_instance_check(self, abctype1, abctype2, inst, _):
# GH 38588, 46719
if abctype1 == abctype2:
assert isinstance(inst, getattr(gt, abctype2))
assert not isinstance(type(inst), getattr(gt, abctype2))
else:
assert not isinstance(inst, getattr(gt, abctype2))
@pytest.mark.parametrize("abctype1, inst", abc_pairs)
@pytest.mark.parametrize("abctype2, _", abc_pairs)
def test_abc_pairs_subclass_check(self, abctype1, abctype2, inst, _):
# GH 38588, 46719
if abctype1 == abctype2:
assert issubclass(type(inst), getattr(gt, abctype2))
with pytest.raises(
TypeError, match=re.escape("issubclass() arg 1 must be a class")
):
issubclass(inst, getattr(gt, abctype2))
else:
assert not issubclass(type(inst), getattr(gt, abctype2))
abc_subclasses = {
"ABCIndex": [
abctype
for abctype, _ in abc_pairs
if "Index" in abctype and abctype != "ABCIndex"
],
"ABCNDFrame": ["ABCSeries", "ABCDataFrame"],
"ABCExtensionArray": [
"ABCCategorical",
"ABCDatetimeArray",
"ABCPeriodArray",
"ABCTimedeltaArray",
],
}
@pytest.mark.parametrize("parent, subs", abc_subclasses.items())
@pytest.mark.parametrize("abctype, inst", abc_pairs)
def test_abc_hierarchy(self, parent, subs, abctype, inst):
# GH 38588
if abctype in subs:
assert isinstance(inst, getattr(gt, parent))
else:
assert not isinstance(inst, getattr(gt, parent))
@pytest.mark.parametrize("abctype", [e for e in gt.__dict__ if e.startswith("ABC")])
def test_abc_coverage(self, abctype):
# GH 38588
assert (
abctype in (e for e, _ in self.abc_pairs) or abctype in self.abc_subclasses
)
>>> arr = RangeIndex(5)
>>> arr / zeros
Float64Index([nan, inf, inf, inf, inf], dtype='float64')
"""
return request.param
# ------------------------------------------------------------------
# Vector Fixtures
@pytest.fixture(
params=[
Float64Index(np.arange(5, dtype="float64")),
Int64Index(np.arange(5, dtype="int64")),
UInt64Index(np.arange(5, dtype="uint64")),
RangeIndex(5),
],
ids=lambda x: type(x).__name__,
)
def numeric_idx(request):
"""
Several types of numeric-dtypes Index objects
"""
return request.param
# ------------------------------------------------------------------
# Scalar Fixtures
def setup_method(self):
self.series_ints = Series(np.random.rand(4), index=np.arange(0, 8, 2))
self.frame_ints = DataFrame(np.random.randn(4, 4),
index=np.arange(0, 8, 2),
columns=np.arange(0, 12, 3))
self.series_uints = Series(np.random.rand(4),
index=UInt64Index(np.arange(0, 8, 2)))
self.frame_uints = DataFrame(
np.random.randn(4, 4),
index=UInt64Index(range(0, 8, 2)),
columns=UInt64Index(range(0, 12, 3)),
)
self.series_floats = Series(np.random.rand(4),
index=Float64Index(range(0, 8, 2)))
self.frame_floats = DataFrame(
np.random.randn(4, 4),
index=Float64Index(range(0, 8, 2)),
columns=Float64Index(range(0, 12, 3)),
)
m_idces = [
MultiIndex.from_product([[1, 2], [3, 4]]),
MultiIndex.from_product([[5, 6], [7, 8]]),
MultiIndex.from_product([[9, 10], [11, 12]]),
]
self.series_multi = Series(np.random.rand(4), index=m_idces[0])
self.frame_multi = DataFrame(np.random.randn(4, 4),
index=m_idces[0],
columns=m_idces[1])
self.series_labels = Series(np.random.randn(4), index=list("abcd"))
self.frame_labels = DataFrame(np.random.randn(4, 4),
index=list("abcd"),
columns=list("ABCD"))
self.series_mixed = Series(np.random.randn(4), index=[2, 4, "null", 8])
self.frame_mixed = DataFrame(np.random.randn(4, 4),
index=[2, 4, "null", 8])
self.series_ts = Series(np.random.randn(4),
index=date_range("20130101", periods=4))
self.frame_ts = DataFrame(np.random.randn(4, 4),
index=date_range("20130101", periods=4))
dates_rev = date_range("20130101",
periods=4).sort_values(ascending=False)
self.series_ts_rev = Series(np.random.randn(4), index=dates_rev)
self.frame_ts_rev = DataFrame(np.random.randn(4, 4), index=dates_rev)
self.frame_empty = DataFrame()
self.series_empty = Series(dtype=object)
# form agglomerates
for kind in self._kinds:
d = {}
for typ in self._typs:
d[typ] = getattr(self, f"{kind}_{typ}")
setattr(self, kind, d)
def test_astype_uint(self):
arr = timedelta_range("1H", periods=2)
expected = UInt64Index(
np.array([3600000000000, 90000000000000], dtype="uint64"))
tm.assert_index_equal(arr.astype("uint64"), expected)
tm.assert_index_equal(arr.astype("uint32"), expected)
