def test_construction_generic(self):
# generic
i = IntervalDtype('interval')
self.assertIs(i.subtype, None)
self.assertTrue(is_interval_dtype(i))
self.assertTrue(str(i) == 'interval')
i = IntervalDtype()
self.assertIs(i.subtype, None)
self.assertTrue(is_interval_dtype(i))
self.assertTrue(str(i) == 'interval')
def test_basic_dtype(self):
self.assertTrue(is_interval_dtype('interval[int64]'))
self.assertTrue(is_interval_dtype(IntervalIndex.from_tuples([(0, 1)])))
self.assertTrue(
is_interval_dtype(IntervalIndex.from_breaks(np.arange(4))))
self.assertTrue(
is_interval_dtype(
IntervalIndex.from_breaks(date_range('20130101', periods=3))))
self.assertFalse(is_interval_dtype('U'))
self.assertFalse(is_interval_dtype('S'))
self.assertFalse(is_interval_dtype('foo'))
self.assertFalse(is_interval_dtype(np.object_))
self.assertFalse(is_interval_dtype(np.int64))
self.assertFalse(is_interval_dtype(np.float64))
def test_basic(self):
self.assertTrue(is_interval_dtype(self.dtype))
ii = IntervalIndex.from_breaks(range(3))
self.assertTrue(is_interval_dtype(ii.dtype))
self.assertTrue(is_interval_dtype(ii))
s = Series(ii, name='A')
# dtypes
# series results in object dtype currently,
self.assertFalse(is_interval_dtype(s.dtype))
self.assertFalse(is_interval_dtype(s))
def test_construction(self):
with tm.assertRaises(ValueError):
IntervalDtype('xx')
for s in ['interval[int64]', 'Interval[int64]', 'int64']:
i = IntervalDtype(s)
self.assertEqual(i.subtype, np.dtype('int64'))
self.assertTrue(is_interval_dtype(i))
def astype(self, dtype, copy=True):
if is_interval_dtype(dtype):
if copy:
self = self.copy()
return self
elif is_object_dtype(dtype):
return Index(self.values, dtype=object)
elif is_categorical_dtype(dtype):
from pandas import Categorical
return Categorical(self, ordered=True)
raise ValueError('Cannot cast IntervalIndex to dtype %s' % dtype)
def equals(self, other):
if self.is_(other):
return True
# if we can coerce to an II
# then we can compare
if not isinstance(other, IntervalIndex):
if not is_interval_dtype(other):
return False
other = Index(getattr(other, '.values', other))
return (self.left.equals(other.left) and self.right.equals(other.right)
and self.closed == other.closed)
def test_setitem(self):
df = DataFrame({'A': range(10)})
s = pd.cut(df.A, 5)
self.assertIsInstance(s.cat.categories, IntervalIndex)
# B & D end up as Categoricals
# the remainer are converted to in-line objects
# contining an IntervalIndex.values
df['B'] = s
df['C'] = np.array(s)
df['D'] = s.values
df['E'] = np.array(s.values)
assert is_categorical_dtype(df['B'])
assert is_interval_dtype(df['B'].cat.categories)
assert is_categorical_dtype(df['D'])
assert is_interval_dtype(df['D'].cat.categories)
assert is_object_dtype(df['C'])
assert is_object_dtype(df['E'])
# they compare equal as Index
# when converted to numpy objects
c = lambda x: Index(np.array(x))
tm.assert_index_equal(c(df.B), c(df.B), check_names=False)
tm.assert_index_equal(c(df.B), c(df.C), check_names=False)
tm.assert_index_equal(c(df.B), c(df.D), check_names=False)
tm.assert_index_equal(c(df.B), c(df.D), check_names=False)
# B & D are the same Series
tm.assert_series_equal(df['B'], df['B'], check_names=False)
tm.assert_series_equal(df['B'], df['D'], check_names=False)
# C & E are the same Series
tm.assert_series_equal(df['C'], df['C'], check_names=False)
tm.assert_series_equal(df['C'], df['E'], check_names=False)
def astype(self, dtype, copy=True):
if is_interval_dtype(dtype):
from pandas import IntervalIndex
return IntervalIndex.from_intervals(np.array(self))
return super(CategoricalIndex, self).astype(dtype=dtype, copy=copy)
