def setup_method(self, method):

self.factor = Categorical(['a', 'b', 'b', 'a', 'a', 'c', 'c', 'c'],

ordered=True)

def test_getitem(self):

assert self.factor[0] == 'a'

assert self.factor[-1] == 'c'

subf = self.factor[[0, 1, 2]]

tm.assert_numpy_array_equal(subf._codes,

np.array([0, 1, 1], dtype=np.int8))

subf = self.factor[np.asarray(self.factor) == 'c']

tm.assert_numpy_array_equal(subf._codes,

np.array([2, 2, 2], dtype=np.int8))

def test_getitem_listlike(self):

# GH 9469

# properly coerce the input indexers

np.random.seed(1)

c = Categorical(np.random.randint(0, 5, size=150000).astype(np.int8))

result = c.codes[np.array([100000]).astype(np.int64)]

expected = c[np.array([100000]).astype(np.int64)].codes

tm.assert_numpy_array_equal(result, expected)

def test_getitem_category_type(self):

# GH 14580

# test iloc() on Series with Categorical data

s = pd.Series([1, 2, 3]).astype('category')

# get slice

result = s.iloc[0:2]

expected = pd.Series([1, 2]).astype('category', categories=[1, 2, 3])

tm.assert_series_equal(result, expected)

# get list of indexes

result = s.iloc[[0, 1]]

expected = pd.Series([1, 2]).astype('category', categories=[1, 2, 3])

tm.assert_series_equal(result, expected)

# get boolean array

result = s.iloc[[True, False, False]]

expected = pd.Series([1]).astype('category', categories=[1, 2, 3])

tm.assert_series_equal(result, expected)

def test_setitem(self):

# int/positional

c = self.factor.copy()

c[0] = 'b'

assert c[0] == 'b'

c[-1] = 'a'

assert c[-1] == 'a'

# boolean

c = self.factor.copy()

indexer = np.zeros(len(c), dtype='bool')

indexer[0] = True

indexer[-1] = True

c[indexer] = 'c'

expected = Categorical(['c', 'b', 'b', 'a', 'a', 'c', 'c', 'c'],

ordered=True)

tm.assert_categorical_equal(c, expected)

def test_setitem_listlike(self):

# GH 9469

# properly coerce the input indexers

np.random.seed(1)

c = Categorical(np.random.randint(0, 5, size=150000).astype(

np.int8)).add_categories([-1000])

indexer = np.array([100000]).astype(np.int64)

c[indexer] = -1000

# we are asserting the code result here

# which maps to the -1000 category

result = c.codes[np.array([100000]).astype(np.int64)]

tm.assert_numpy_array_equal(result, np.array([5], dtype='int8'))

def test_constructor_empty(self):

# GH 17248

c = Categorical([])

expected = Index([])

tm.assert_index_equal(c.categories, expected)

c = Categorical([], categories=[1, 2, 3])

expected = pd.Int64Index([1, 2, 3])

tm.assert_index_equal(c.categories, expected)

def test_constructor_unsortable(self):

# it works!

arr = np.array([1, 2, 3, datetime.now()], dtype='O')

factor = Categorical(arr, ordered=False)

assert not factor.ordered

# this however will raise as cannot be sorted

pytest.raises(

TypeError, lambda: Categorical(arr, ordered=True))

def test_constructor_interval(self):

result = Categorical([Interval(1, 2), Interval(2, 3), Interval(3, 6)],

ordered=True)

ii = IntervalIndex.from_intervals([Interval(1, 2),

Interval(2, 3),

Interval(3, 6)])

exp = Categorical(ii, ordered=True)

tm.assert_categorical_equal(result, exp)

tm.assert_index_equal(result.categories, ii)

def test_is_equal_dtype(self):

# test dtype comparisons between cats

c1 = Categorical(list('aabca'), categories=list('abc'), ordered=False)

c2 = Categorical(list('aabca'), categories=list('cab'), ordered=False)

c3 = Categorical(list('aabca'), categories=list('cab'), ordered=True)

assert c1.is_dtype_equal(c1)

assert c2.is_dtype_equal(c2)

assert c3.is_dtype_equal(c3)

assert not c1.is_dtype_equal(c2)

assert not c1.is_dtype_equal(c3)

assert not c1.is_dtype_equal(Index(list('aabca')))

assert not c1.is_dtype_equal(c1.astype(object))

assert c1.is_dtype_equal(CategoricalIndex(c1))

assert not (c1.is_dtype_equal(

CategoricalIndex(c1, categories=list('cab'))))

assert not c1.is_dtype_equal(CategoricalIndex(c1, ordered=True))

def test_constructor(self):

exp_arr = np.array(["a", "b", "c", "a", "b", "c"], dtype=np.object_)

c1 = Categorical(exp_arr)

tm.assert_numpy_array_equal(c1.__array__(), exp_arr)

c2 = Categorical(exp_arr, categories=["a", "b", "c"])

tm.assert_numpy_array_equal(c2.__array__(), exp_arr)

c2 = Categorical(exp_arr, categories=["c", "b", "a"])

tm.assert_numpy_array_equal(c2.__array__(), exp_arr)

# categories must be unique

def f():

Categorical([1, 2], [1, 2, 2])

pytest.raises(ValueError, f)

def f():

Categorical(["a", "b"], ["a", "b", "b"])

pytest.raises(ValueError, f)

# The default should be unordered

c1 = Categorical(["a", "b", "c", "a"])

assert not c1.ordered

# Categorical as input

c1 = Categorical(["a", "b", "c", "a"])

c2 = Categorical(c1)

tm.assert_categorical_equal(c1, c2)

c1 = Categorical(["a", "b", "c", "a"], categories=["a", "b", "c", "d"])

c2 = Categorical(c1)

tm.assert_categorical_equal(c1, c2)

c1 = Categorical(["a", "b", "c", "a"], categories=["a", "c", "b"])

c2 = Categorical(c1)

tm.assert_categorical_equal(c1, c2)

c1 = Categorical(["a", "b", "c", "a"], categories=["a", "c", "b"])

c2 = Categorical(c1, categories=["a", "b", "c"])

tm.assert_numpy_array_equal(c1.__array__(), c2.__array__())

tm.assert_index_equal(c2.categories, Index(["a", "b", "c"]))

# Series of dtype category

c1 = Categorical(["a", "b", "c", "a"], categories=["a", "b", "c", "d"])

c2 = Categorical(Series(c1))

tm.assert_categorical_equal(c1, c2)

c1 = Categorical(["a", "b", "c", "a"], categories=["a", "c", "b"])

c2 = Categorical(Series(c1))

tm.assert_categorical_equal(c1, c2)

# Series

c1 = Categorical(["a", "b", "c", "a"])

c2 = Categorical(Series(["a", "b", "c", "a"]))

tm.assert_categorical_equal(c1, c2)

c1 = Categorical(["a", "b", "c", "a"], categories=["a", "b", "c", "d"])

c2 = Categorical(Series(["a", "b", "c", "a"]),

categories=["a", "b", "c", "d"])

tm.assert_categorical_equal(c1, c2)

# This should result in integer categories, not float!

cat = pd.Categorical([1, 2, 3, np.nan], categories=[1, 2, 3])

assert is_integer_dtype(cat.categories)

# https://github.com/pandas-dev/pandas/issues/3678

cat = pd.Categorical([np.nan, 1, 2, 3])

assert is_integer_dtype(cat.categories)

# this should result in floats

cat = pd.Categorical([np.nan, 1, 2., 3])

assert is_float_dtype(cat.categories)

cat = pd.Categorical([np.nan, 1., 2., 3.])

assert is_float_dtype(cat.categories)

# This doesn't work -> this would probably need some kind of "remember

# the original type" feature to try to cast the array interface result

# to...

# vals = np.asarray(cat[cat.notna()])

# assert is_integer_dtype(vals)

# corner cases

cat = pd.Categorical([1])

assert len(cat.categories) == 1

assert cat.categories[0] == 1

assert len(cat.codes) == 1

assert cat.codes[0] == 0

cat = pd.Categorical(["a"])

assert len(cat.categories) == 1

assert cat.categories[0] == "a"

assert len(cat.codes) == 1

assert cat.codes[0] == 0

# Scalars should be converted to lists

cat = pd.Categorical(1)

assert len(cat.categories) == 1

assert cat.categories[0] == 1

assert len(cat.codes) == 1

assert cat.codes[0] == 0

# Catch old style constructor useage: two arrays, codes + categories

# We can only catch two cases:

# - when the first is an integer dtype and the second is not

# - when the resulting codes are all -1/NaN

with tm.assert_produces_warning(RuntimeWarning):

c_old = Categorical([0, 1, 2, 0, 1, 2],

categories=["a", "b", "c"]) # noqa

with tm.assert_produces_warning(RuntimeWarning):

c_old = Categorical([0, 1, 2, 0, 1, 2], # noqa

categories=[3, 4, 5])

# the next one are from the old docs, but unfortunately these don't

# trigger :-(

with tm.assert_produces_warning(None):

c_old2 = Categorical([0, 1, 2, 0, 1, 2], [1, 2, 3]) # noqa

cat = Categorical([1, 2], categories=[1, 2, 3])

# this is a legitimate constructor

with tm.assert_produces_warning(None):

c = Categorical(np.array([], dtype='int64'), # noqa

categories=[3, 2, 1], ordered=True)

def test_constructor_not_sequence(self):

# https://github.com/pandas-dev/pandas/issues/16022

with pytest.raises(TypeError):

Categorical(['a', 'b'], categories='a')

def test_constructor_with_null(self):

# Cannot have NaN in categories

with pytest.raises(ValueError):

pd.Categorical([np.nan, "a", "b", "c"],

categories=[np.nan, "a", "b", "c"])

with pytest.raises(ValueError):

pd.Categorical([None, "a", "b", "c"],

categories=[None, "a", "b", "c"])

with pytest.raises(ValueError):

pd.Categorical(DatetimeIndex(['nat', '20160101']),

categories=[NaT, Timestamp('20160101')])

def test_constructor_with_index(self):

ci = CategoricalIndex(list('aabbca'), categories=list('cab'))

tm.assert_categorical_equal(ci.values, Categorical(ci))

ci = CategoricalIndex(list('aabbca'), categories=list('cab'))

tm.assert_categorical_equal(ci.values,

Categorical(ci.astype(object),

categories=ci.categories))

def test_constructor_with_generator(self):

# This was raising an Error in isna(single_val).any() because isna

# returned a scalar for a generator

xrange = range

exp = Categorical([0, 1, 2])

cat = Categorical((x for x in [0, 1, 2]))

tm.assert_categorical_equal(cat, exp)

cat = Categorical(xrange(3))

tm.assert_categorical_equal(cat, exp)

# This uses xrange internally

from pandas.core.index import MultiIndex

MultiIndex.from_product([range(5), ['a', 'b', 'c']])

# check that categories accept generators and sequences

cat = pd.Categorical([0, 1, 2], categories=(x for x in [0, 1, 2]))

tm.assert_categorical_equal(cat, exp)

cat = pd.Categorical([0, 1, 2], categories=xrange(3))

tm.assert_categorical_equal(cat, exp)

def test_constructor_with_datetimelike(self):

# 12077

# constructor wwth a datetimelike and NaT

for dtl in [pd.date_range('1995-01-01 00:00:00',

periods=5, freq='s'),

pd.date_range('1995-01-01 00:00:00',

periods=5, freq='s', tz='US/Eastern'),

pd.timedelta_range('1 day', periods=5, freq='s')]:

s = Series(dtl)

c = Categorical(s)

expected = type(dtl)(s)

expected.freq = None

tm.assert_index_equal(c.categories, expected)

tm.assert_numpy_array_equal(c.codes, np.arange(5, dtype='int8'))

# with NaT

s2 = s.copy()

s2.iloc[-1] = pd.NaT

c = Categorical(s2)

expected = type(dtl)(s2.dropna())

expected.freq = None

tm.assert_index_equal(c.categories, expected)

exp = np.array([0, 1, 2, 3, -1], dtype=np.int8)

tm.assert_numpy_array_equal(c.codes, exp)

result = repr(c)

assert 'NaT' in result

def test_constructor_from_index_series_datetimetz(self):

idx = pd.date_range('2015-01-01 10:00', freq='D', periods=3,

tz='US/Eastern')

result = pd.Categorical(idx)

tm.assert_index_equal(result.categories, idx)

result = pd.Categorical(pd.Series(idx))

tm.assert_index_equal(result.categories, idx)

def test_constructor_from_index_series_timedelta(self):

idx = pd.timedelta_range('1 days', freq='D', periods=3)

result = pd.Categorical(idx)

tm.assert_index_equal(result.categories, idx)

result = pd.Categorical(pd.Series(idx))

tm.assert_index_equal(result.categories, idx)

def test_constructor_from_index_series_period(self):

idx = pd.period_range('2015-01-01', freq='D', periods=3)

result = pd.Categorical(idx)

tm.assert_index_equal(result.categories, idx)

result = pd.Categorical(pd.Series(idx))

tm.assert_index_equal(result.categories, idx)

def test_constructor_invariant(self):

# GH 14190

vals = [

np.array([1., 1.2, 1.8, np.nan]),

np.array([1, 2, 3], dtype='int64'),

['a', 'b', 'c', np.nan],

[pd.Period('2014-01'), pd.Period('2014-02'), pd.NaT],

[pd.Timestamp('2014-01-01'), pd.Timestamp('2014-01-02'), pd.NaT],

[pd.Timestamp('2014-01-01', tz='US/Eastern'),

pd.Timestamp('2014-01-02', tz='US/Eastern'), pd.NaT],

]

for val in vals:

c = Categorical(val)

c2 = Categorical(c)

tm.assert_categorical_equal(c, c2)

def test_from_codes(self):

# too few categories

def f():

Categorical.from_codes([1, 2], [1, 2])

pytest.raises(ValueError, f)

# no int codes

def f():

Categorical.from_codes(["a"], [1, 2])

pytest.raises(ValueError, f)

# no unique categories

def f():

Categorical.from_codes([0, 1, 2], ["a", "a", "b"])

pytest.raises(ValueError, f)

# NaN categories included

def f():

Categorical.from_codes([0, 1, 2], ["a", "b", np.nan])

pytest.raises(ValueError, f)

# too negative

def f():

Categorical.from_codes([-2, 1, 2], ["a", "b", "c"])

pytest.raises(ValueError, f)

exp = Categorical(["a", "b", "c"], ordered=False)

res = Categorical.from_codes([0, 1, 2], ["a", "b", "c"])

tm.assert_categorical_equal(exp, res)

# Not available in earlier numpy versions

if hasattr(np.random, "choice"):

codes = np.random.choice([0, 1], 5, p=[0.9, 0.1])

pd.Categorical.from_codes(codes, categories=["train", "test"])

def test_validate_ordered(self):

# see gh-14058

exp_msg = "'ordered' must either be 'True' or 'False'"

exp_err = TypeError

# This should be a boolean.

ordered = np.array([0, 1, 2])

with tm.assert_raises_regex(exp_err, exp_msg):

Categorical([1, 2, 3], ordered=ordered)

with tm.assert_raises_regex(exp_err, exp_msg):

Categorical.from_codes([0, 0, 1], categories=['a', 'b', 'c'],

ordered=ordered)

def test_comparisons(self):

result = self.factor[self.factor == 'a']

expected = self.factor[np.asarray(self.factor) == 'a']

tm.assert_categorical_equal(result, expected)

result = self.factor[self.factor != 'a']

expected = self.factor[np.asarray(self.factor) != 'a']

tm.assert_categorical_equal(result, expected)

result = self.factor[self.factor < 'c']

expected = self.factor[np.asarray(self.factor) < 'c']

tm.assert_categorical_equal(result, expected)

result = self.factor[self.factor > 'a']

expected = self.factor[np.asarray(self.factor) > 'a']

tm.assert_categorical_equal(result, expected)

result = self.factor[self.factor >= 'b']

expected = self.factor[np.asarray(self.factor) >= 'b']

tm.assert_categorical_equal(result, expected)

result = self.factor[self.factor <= 'b']

expected = self.factor[np.asarray(self.factor) <= 'b']

tm.assert_categorical_equal(result, expected)

n = len(self.factor)

other = self.factor[np.random.permutation(n)]

result = self.factor == other

expected = np.asarray(self.factor) == np.asarray(other)

tm.assert_numpy_array_equal(result, expected)

result = self.factor == 'd'

expected = np.repeat(False, len(self.factor))

tm.assert_numpy_array_equal(result, expected)

# comparisons with categoricals

cat_rev = pd.Categorical(["a", "b", "c"], categories=["c", "b", "a"],

ordered=True)

cat_rev_base = pd.Categorical(

["b", "b", "b"], categories=["c", "b", "a"], ordered=True)

cat = pd.Categorical(["a", "b", "c"], ordered=True)

cat_base = pd.Categorical(["b", "b", "b"], categories=cat.categories,

ordered=True)

# comparisons need to take categories ordering into account

res_rev = cat_rev > cat_rev_base

exp_rev = np.array([True, False, False])

tm.assert_numpy_array_equal(res_rev, exp_rev)

res_rev = cat_rev < cat_rev_base

exp_rev = np.array([False, False, True])

tm.assert_numpy_array_equal(res_rev, exp_rev)

res = cat > cat_base

exp = np.array([False, False, True])

tm.assert_numpy_array_equal(res, exp)

# Only categories with same categories can be compared

def f():

cat > cat_rev

pytest.raises(TypeError, f)

cat_rev_base2 = pd.Categorical(

["b", "b", "b"], categories=["c", "b", "a", "d"])

def f():

cat_rev > cat_rev_base2

pytest.raises(TypeError, f)

# Only categories with same ordering information can be compared

cat_unorderd = cat.set_ordered(False)

assert not (cat > cat).any()

def f():

cat > cat_unorderd

pytest.raises(TypeError, f)

# comparison (in both directions) with Series will raise

s = Series(["b", "b", "b"])

pytest.raises(TypeError, lambda: cat > s)

pytest.raises(TypeError, lambda: cat_rev > s)

pytest.raises(TypeError, lambda: s < cat)

pytest.raises(TypeError, lambda: s < cat_rev)

# comparison with numpy.array will raise in both direction, but only on

# newer numpy versions

a = np.array(["b", "b", "b"])

pytest.raises(TypeError, lambda: cat > a)

pytest.raises(TypeError, lambda: cat_rev > a)

# The following work via '__array_priority__ = 1000'

# works only on numpy >= 1.7.1

if LooseVersion(np.__version__) > "1.7.1":

pytest.raises(TypeError, lambda: a < cat)

pytest.raises(TypeError, lambda: a < cat_rev)

# Make sure that unequal comparison take the categories order in

# account

cat_rev = pd.Categorical(

list("abc"), categories=list("cba"), ordered=True)

exp = np.array([True, False, False])

res = cat_rev > "b"

tm.assert_numpy_array_equal(res, exp)

def test_argsort(self):

c = Categorical([5, 3, 1, 4, 2], ordered=True)

expected = np.array([2, 4, 1, 3, 0])

tm.assert_numpy_array_equal(c.argsort(ascending=True), expected,

check_dtype=False)

expected = expected[::-1]

tm.assert_numpy_array_equal(c.argsort(ascending=False), expected,

check_dtype=False)

def test_numpy_argsort(self):

c = Categorical([5, 3, 1, 4, 2], ordered=True)

expected = np.array([2, 4, 1, 3, 0])

tm.assert_numpy_array_equal(np.argsort(c), expected,

check_dtype=False)

tm.assert_numpy_array_equal(np.argsort(c, kind='mergesort'), expected,

check_dtype=False)

msg = "the 'axis' parameter is not supported"

tm.assert_raises_regex(ValueError, msg, np.argsort,

c, axis=0)

msg = "the 'order' parameter is not supported"

tm.assert_raises_regex(ValueError, msg, np.argsort,

c, order='C')

def test_na_flags_int_categories(self):

# #1457

categories = lrange(10)

labels = np.random.randint(0, 10, 20)

labels[::5] = -1

cat = Categorical(labels, categories, fastpath=True)

repr(cat)

tm.assert_numpy_array_equal(isna(cat), labels == -1)

def test_categories_none(self):

factor = Categorical(['a', 'b', 'b', 'a',

'a', 'c', 'c', 'c'], ordered=True)

tm.assert_categorical_equal(factor, self.factor)

def test_describe(self):

# string type

desc = self.factor.describe()

assert self.factor.ordered

exp_index = pd.CategoricalIndex(['a', 'b', 'c'], name='categories',

ordered=self.factor.ordered)

expected = DataFrame({'counts': [3, 2, 3],

'freqs': [3 / 8., 2 / 8., 3 / 8.]},

index=exp_index)

tm.assert_frame_equal(desc, expected)

# check unused categories

cat = self.factor.copy()

cat.set_categories(["a", "b", "c", "d"], inplace=True)

desc = cat.describe()

exp_index = pd.CategoricalIndex(['a', 'b', 'c', 'd'],

ordered=self.factor.ordered,

name='categories')

expected = DataFrame({'counts': [3, 2, 3, 0],

'freqs': [3 / 8., 2 / 8., 3 / 8., 0]},

index=exp_index)

tm.assert_frame_equal(desc, expected)

# check an integer one

cat = Categorical([1, 2, 3, 1, 2, 3, 3, 2, 1, 1, 1])

desc = cat.describe()

exp_index = pd.CategoricalIndex([1, 2, 3], ordered=cat.ordered,

name='categories')

expected = DataFrame({'counts': [5, 3, 3],

'freqs': [5 / 11., 3 / 11., 3 / 11.]},

index=exp_index)

tm.assert_frame_equal(desc, expected)

# https://github.com/pandas-dev/pandas/issues/3678

# describe should work with NaN

cat = pd.Categorical([np.nan, 1, 2, 2])

desc = cat.describe()

expected = DataFrame({'counts': [1, 2, 1],

'freqs': [1 / 4., 2 / 4., 1 / 4.]},

index=pd.CategoricalIndex([1, 2, np.nan],

categories=[1, 2],

name='categories'))

tm.assert_frame_equal(desc, expected)

def test_print(self):

expected = ["[a, b, b, a, a, c, c, c]",

"Categories (3, object): [a < b < c]"]

expected = "\n".join(expected)

actual = repr(self.factor)

assert actual == expected

def test_big_print(self):

factor = Categorical([0, 1, 2, 0, 1, 2] * 100, ['a', 'b', 'c'],

fastpath=True)

expected = ["[a, b, c, a, b, ..., b, c, a, b, c]", "Length: 600",

"Categories (3, object): [a, b, c]"]

expected = "\n".join(expected)

actual = repr(factor)

assert actual == expected

def test_empty_print(self):

factor = Categorical([], ["a", "b", "c"])

expected = ("[], Categories (3, object): [a, b, c]")

# hack because array_repr changed in numpy > 1.6.x

actual = repr(factor)

assert actual == expected

assert expected == actual

factor = Categorical([], ["a", "b", "c"], ordered=True)

expected = ("[], Categories (3, object): [a < b < c]")

actual = repr(factor)

assert expected == actual

factor = Categorical([], [])

expected = ("[], Categories (0, object): []")

assert expected == repr(factor)

def test_print_none_width(self):

# GH10087

a = pd.Series(pd.Categorical([1, 2, 3, 4]))

exp = u("0 1\n1 2\n2 3\n3 4\n" +

"dtype: category\nCategories (4, int64): [1, 2, 3, 4]")

with option_context("display.width", None):

assert exp == repr(a)

def test_unicode_print(self):

if PY3:

_rep = repr

else:

_rep = unicode # noqa

c = pd.Categorical(['aaaaa', 'bb', 'cccc'] * 20)

expected = u"""\

[aaaaa, bb, cccc, aaaaa, bb, ..., bb, cccc, aaaaa, bb, cccc]

Length: 60

Categories (3, object): [aaaaa, bb, cccc]"""

assert _rep(c) == expected

c = pd.Categorical([u'ああああ', u'いいいいい', u'ううううううう'] * 20)

expected = u"""\

[ああああ, いいいいい, ううううううう, ああああ, いいいいい, ..., いいいいい, ううううううう, ああああ, いいいいい, ううううううう]

Length: 60

Categories (3, object): [ああああ, いいいいい, ううううううう]""" # noqa

assert _rep(c) == expected

# unicode option should not affect to Categorical, as it doesn't care

# the repr width

with option_context('display.unicode.east_asian_width', True):

c = pd.Categorical([u'ああああ', u'いいいいい', u'ううううううう'] * 20)

expected = u"""[ああああ, いいいいい, ううううううう, ああああ, いいいいい, ..., いいいいい, ううううううう, ああああ, いいいいい, ううううううう]

Length: 60

Categories (3, object): [ああああ, いいいいい, ううううううう]""" # noqa

assert _rep(c) == expected

def test_tab_complete_warning(self, ip):

# https://github.com/pandas-dev/pandas/issues/16409

pytest.importorskip('IPython', minversion="6.0.0")

from IPython.core.completer import provisionalcompleter

code = "import pandas as pd; c = pd.Categorical([])"

ip.run_code(code)

with tm.assert_produces_warning(None):

with provisionalcompleter('ignore'):

list(ip.Completer.completions('c.', 1))

def test_periodindex(self):

idx1 = PeriodIndex(['2014-01', '2014-01', '2014-02', '2014-02',

'2014-03', '2014-03'], freq='M')

cat1 = Categorical(idx1)

str(cat1)

exp_arr = np.array([0, 0, 1, 1, 2, 2], dtype=np.int8)

exp_idx = PeriodIndex(['2014-01', '2014-02', '2014-03'], freq='M')

tm.assert_numpy_array_equal(cat1._codes, exp_arr)

tm.assert_index_equal(cat1.categories, exp_idx)

idx2 = PeriodIndex(['2014-03', '2014-03', '2014-02', '2014-01',

'2014-03', '2014-01'], freq='M')

cat2 = Categorical(idx2, ordered=True)

str(cat2)

exp_arr = np.array([2, 2, 1, 0, 2, 0], dtype=np.int8)

exp_idx2 = PeriodIndex(['2014-01', '2014-02', '2014-03'], freq='M')

tm.assert_numpy_array_equal(cat2._codes, exp_arr)

tm.assert_index_equal(cat2.categories, exp_idx2)

idx3 = PeriodIndex(['2013-12', '2013-11', '2013-10', '2013-09',

'2013-08', '2013-07', '2013-05'], freq='M')

cat3 = Categorical(idx3, ordered=True)

exp_arr = np.array([6, 5, 4, 3, 2, 1, 0], dtype=np.int8)

exp_idx = PeriodIndex(['2013-05', '2013-07', '2013-08', '2013-09',

'2013-10', '2013-11', '2013-12'], freq='M')

tm.assert_numpy_array_equal(cat3._codes, exp_arr)

tm.assert_index_equal(cat3.categories, exp_idx)

def test_categories_assigments(self):

s = pd.Categorical(["a", "b", "c", "a"])

exp = np.array([1, 2, 3, 1], dtype=np.int64)

s.categories = [1, 2, 3]

tm.assert_numpy_array_equal(s.__array__(), exp)

tm.assert_index_equal(s.categories, Index([1, 2, 3]))

# lengthen

def f():

s.categories = [1, 2, 3, 4]

pytest.raises(ValueError, f)

# shorten

def f():

s.categories = [1, 2]

pytest.raises(ValueError, f)

def test_construction_with_ordered(self):

# GH 9347, 9190

cat = Categorical([0, 1, 2])

assert not cat.ordered

cat = Categorical([0, 1, 2], ordered=False)

assert not cat.ordered

cat = Categorical([0, 1, 2], ordered=True)

assert cat.ordered

def test_ordered_api(self):

# GH 9347

cat1 = pd.Categorical(["a", "c", "b"], ordered=False)

tm.assert_index_equal(cat1.categories, Index(['a', 'b', 'c']))

assert not cat1.ordered

cat2 = pd.Categorical(["a", "c", "b"], categories=['b', 'c', 'a'],

ordered=False)

tm.assert_index_equal(cat2.categories, Index(['b', 'c', 'a']))

assert not cat2.ordered

cat3 = pd.Categorical(["a", "c", "b"], ordered=True)

tm.assert_index_equal(cat3.categories, Index(['a', 'b', 'c']))

assert cat3.ordered

cat4 = pd.Categorical(["a", "c", "b"], categories=['b', 'c', 'a'],

ordered=True)

tm.assert_index_equal(cat4.categories, Index(['b', 'c', 'a']))

assert cat4.ordered

def test_set_ordered(self):

cat = Categorical(["a", "b", "c", "a"], ordered=True)

cat2 = cat.as_unordered()

assert not cat2.ordered

cat2 = cat.as_ordered()

assert cat2.ordered

cat2.as_unordered(inplace=True)

assert not cat2.ordered

cat2.as_ordered(inplace=True)

assert cat2.ordered

assert cat2.set_ordered(True).ordered

assert not cat2.set_ordered(False).ordered

cat2.set_ordered(True, inplace=True)

assert cat2.ordered

cat2.set_ordered(False, inplace=True)

assert not cat2.ordered

# removed in 0.19.0

msg = "can\'t set attribute"

with tm.assert_raises_regex(AttributeError, msg):

cat.ordered = True

with tm.assert_raises_regex(AttributeError, msg):

cat.ordered = False

def test_set_categories(self):

cat = Categorical(["a", "b", "c", "a"], ordered=True)

exp_categories = Index(["c", "b", "a"])

exp_values = np.array(["a", "b", "c", "a"], dtype=np.object_)

res = cat.set_categories(["c", "b", "a"], inplace=True)

tm.assert_index_equal(cat.categories, exp_categories)

tm.assert_numpy_array_equal(cat.__array__(), exp_values)

assert res is None

res = cat.set_categories(["a", "b", "c"])

# cat must be the same as before

tm.assert_index_equal(cat.categories, exp_categories)

tm.assert_numpy_array_equal(cat.__array__(), exp_values)

# only res is changed

exp_categories_back = Index(["a", "b", "c"])

tm.assert_index_equal(res.categories, exp_categories_back)

tm.assert_numpy_array_equal(res.__array__(), exp_values)

# not all "old" included in "new" -> all not included ones are now

# np.nan

cat = Categorical(["a", "b", "c", "a"], ordered=True)

res = cat.set_categories(["a"])

tm.assert_numpy_array_equal(res.codes, np.array([0, -1, -1, 0],

dtype=np.int8))

# still not all "old" in "new"

res = cat.set_categories(["a", "b", "d"])

tm.assert_numpy_array_equal(res.codes, np.array([0, 1, -1, 0],

dtype=np.int8))

tm.assert_index_equal(res.categories, Index(["a", "b", "d"]))

# all "old" included in "new"

cat = cat.set_categories(["a", "b", "c", "d"])

exp_categories = Index(["a", "b", "c", "d"])

tm.assert_index_equal(cat.categories, exp_categories)

# internals...

c = Categorical([1, 2, 3, 4, 1], categories=[1, 2, 3, 4], ordered=True)

tm.assert_numpy_array_equal(c._codes, np.array([0, 1, 2, 3, 0],

dtype=np.int8))

tm.assert_index_equal(c.categories, Index([1, 2, 3, 4]))

exp = np.array([1, 2, 3, 4, 1], dtype=np.int64)

tm.assert_numpy_array_equal(c.get_values(), exp)

# all "pointers" to '4' must be changed from 3 to 0,...

c = c.set_categories([4, 3, 2, 1])

# positions are changed

tm.assert_numpy_array_equal(c._codes, np.array([3, 2, 1, 0, 3],

dtype=np.int8))

# categories are now in new order

tm.assert_index_equal(c.categories, Index([4, 3, 2, 1]))

# output is the same

exp = np.array([1, 2, 3, 4, 1], dtype=np.int64)

tm.assert_numpy_array_equal(c.get_values(), exp)

assert c.min() == 4

assert c.max() == 1

# set_categories should set the ordering if specified

c2 = c.set_categories([4, 3, 2, 1], ordered=False)

assert not c2.ordered

tm.assert_numpy_array_equal(c.get_values(), c2.get_values())

# set_categories should pass thru the ordering

c2 = c.set_ordered(False).set_categories([4, 3, 2, 1])

assert not c2.ordered

tm.assert_numpy_array_equal(c.get_values(), c2.get_values())

def test_rename_categories(self):

cat = pd.Categorical(["a", "b", "c", "a"])

# inplace=False: the old one must not be changed

res = cat.rename_categories([1, 2, 3])

tm.assert_numpy_array_equal(res.__array__(), np.array([1, 2, 3, 1],

dtype=np.int64))

tm.assert_index_equal(res.categories, Index([1, 2, 3]))

exp_cat = np.array(["a", "b", "c", "a"], dtype=np.object_)

tm.assert_numpy_array_equal(cat.__array__(), exp_cat)

exp_cat = Index(["a", "b", "c"])

tm.assert_index_equal(cat.categories, exp_cat)

res = cat.rename_categories([1, 2, 3], inplace=True)

# and now inplace

assert res is None

tm.assert_numpy_array_equal(cat.__array__(), np.array([1, 2, 3, 1],

dtype=np.int64))

tm.assert_index_equal(cat.categories, Index([1, 2, 3]))

# Lengthen

with pytest.raises(ValueError):

cat.rename_categories([1, 2, 3, 4])

# Shorten

with pytest.raises(ValueError):

cat.rename_categories([1, 2])

def test_reorder_categories(self):

cat = Categorical(["a", "b", "c", "a"], ordered=True)

old = cat.copy()

new = Categorical(["a", "b", "c", "a"], categories=["c", "b", "a"],

ordered=True)

# first inplace == False

res = cat.reorder_categories(["c", "b", "a"])

# cat must be the same as before

tm.assert_categorical_equal(cat, old)

# only res is changed

tm.assert_categorical_equal(res, new)

# inplace == True

res = cat.reorder_categories(["c", "b", "a"], inplace=True)

assert res is None

tm.assert_categorical_equal(cat, new)

# not all "old" included in "new"

cat = Categorical(["a", "b", "c", "a"], ordered=True)

def f():

cat.reorder_categories(["a"])

pytest.raises(ValueError, f)

# still not all "old" in "new"

def f():

cat.reorder_categories(["a", "b", "d"])

pytest.raises(ValueError, f)

# all "old" included in "new", but too long

def f():

cat.reorder_categories(["a", "b", "c", "d"])