def test_mod(self): for pser, psser in self.numeric_pser_psser_pairs: self.assert_eq(pser % pser, psser % psser) self.assert_eq(pser % pser.astype(bool), psser % psser.astype(bool)) self.assert_eq(pser % True, psser % True) if psser.dtype in [int, np.int32]: self.assert_eq( ps.Series([np.nan, np.nan, np.nan], dtype=float), psser % False) else: self.assert_eq( ps.Series([np.nan, np.nan, np.nan], dtype=psser.dtype), psser % False) with option_context("compute.ops_on_diff_frames", True): for pser, psser in self.numeric_pser_psser_pairs: self.assertRaises( TypeError, lambda: psser % self.non_numeric_pssers["string"]) self.assertRaises( TypeError, lambda: psser % self.non_numeric_pssers["datetime"]) self.assertRaises( TypeError, lambda: psser % self.non_numeric_pssers["date"]) self.assertRaises( TypeError, lambda: psser % self.non_numeric_pssers["categorical"]) self.assert_eq( (self.float_psser % self.non_numeric_pssers["bool"]).sort_index(), self.float_pser % self.non_numeric_psers["bool"], )
def test_mul(self): pser = self.pser psser = self.psser self.assert_eq((pser * 1).astype(float), psser * 1) self.assert_eq((pser * 0.1).astype(float), psser * 0.1) # In pandas, NA & False is NA, whereas NA & False is False in pandas-on-Spark if LooseVersion(pd.__version__) >= LooseVersion("1.2.2"): self.assert_eq(pser * True, psser * True) self.assert_eq(ps.Series([False, False, False], dtype="boolean"), psser * False) self.assert_eq(pser * pser, psser * psser) else: # Due to https://github.com/pandas-dev/pandas/issues/39410 self.assert_eq([True, False, pd._libs.missing.NAType()], (psser * True).tolist()) self.assert_eq(ps.Series([False, False, False]), (psser * False).astype(bool)) self.assert_eq([True, False, pd._libs.missing.NAType()], (psser * psser).tolist()) with option_context("compute.ops_on_diff_frames", True): for pser, psser in self.numeric_pser_psser_pairs: self.assert_eq(self.pser * pser, (self.psser * psser).sort_index(), almost=True) for psser in self.non_numeric_pssers.values(): if not isinstance(psser.spark.data_type, BooleanType): self.assertRaises(TypeError, lambda: self.psser * psser) bool_pser = pd.Series([True, True, True]) bool_psser = ps.from_pandas(bool_pser) if LooseVersion(pd.__version__) >= LooseVersion("1.2.2"): self.assert_eq(self.pser * bool_pser, self.psser * bool_psser) else: # Due to https://github.com/pandas-dev/pandas/issues/39410 self.assert_eq( [True, False, pd._libs.missing.NAType()], (self.psser * bool_psser).tolist() )
def test_rfloordiv(self): self.assert_eq((1 // self.psser).astype(float), ps.Series([1.0, np.inf, np.nan])) self.assert_eq((0.1 // self.psser).astype(float), ps.Series([0.0, np.inf, np.nan])) self.assertRaises(TypeError, lambda: "x" // self.psser) self.assertRaises(TypeError, lambda: True // self.psser) self.assertRaises(TypeError, lambda: datetime.date(1994, 1, 1) // self.psser) self.assertRaises(TypeError, lambda: datetime.datetime(1994, 1, 1) // self.psser)
def test_expanding_count(self): # The behaviour of Expanding.count are different between pandas>=1.0.0 and lower, # and we're following the behaviour of latest version of pandas. if LooseVersion(pd.__version__) >= LooseVersion("1.0.0"): self._test_expanding_func("count") else: # Series idx = np.random.rand(3) psser = ps.Series([1, 2, 3], index=idx, name="a") expected_result = pd.Series([None, 2.0, 3.0], index=idx, name="a") self.assert_eq(psser.expanding(2).count().sort_index(), expected_result.sort_index()) self.assert_eq(psser.expanding(2).count().sum(), expected_result.sum()) # MultiIndex midx = pd.MultiIndex.from_tuples([("a", "x"), ("a", "y"), ("b", "z")]) psser = ps.Series([1, 2, 3], index=midx, name="a") expected_result = pd.Series([None, 2.0, 3.0], index=midx, name="a") self.assert_eq(psser.expanding(2).count().sort_index(), expected_result.sort_index()) # DataFrame psdf = ps.DataFrame({"a": [1, 2, 3, 2], "b": [4.0, 2.0, 3.0, 1.0]}) expected_result = pd.DataFrame({"a": [None, 2.0, 3.0, 4.0], "b": [None, 2.0, 3.0, 4.0]}) self.assert_eq(psdf.expanding(2).count().sort_index(), expected_result.sort_index()) self.assert_eq(psdf.expanding(2).count().sum(), expected_result.sum()) # MultiIndex columns idx = np.random.rand(4) psdf = ps.DataFrame({"a": [1, 2, 3, 2], "b": [4.0, 2.0, 3.0, 1.0]}, index=idx) psdf.columns = pd.MultiIndex.from_tuples([("a", "x"), ("a", "y")]) expected_result = pd.DataFrame( {("a", "x"): [None, 2.0, 3.0, 4.0], ("a", "y"): [None, 2.0, 3.0, 4.0]}, index=idx, ) self.assert_eq(psdf.expanding(2).count().sort_index(), expected_result.sort_index())
def test_neg(self): # pandas raises "TypeError: bad operand type for unary -: 'FloatingArray'" for dtype in self.fractional_extension_dtypes: self.assert_eq( ps.Series([-0.1, -0.2, -0.3, None], dtype=dtype), -ps.Series([0.1, 0.2, 0.3, None], dtype=dtype), )
def test_rmod(self): self.assert_eq(ps.Series([0, np.nan, np.nan], dtype=float), 1 % self.psser) self.assert_eq( ps.Series([0.10000000000000009, np.nan, np.nan], dtype=float), 0.1 % self.psser, ) self.assertRaises(TypeError, lambda: datetime.date(1994, 1, 1) % self.psser) self.assertRaises(TypeError, lambda: True % self.psser)
def test_rmod(self): # 1 % False is 0.0 in pandas self.assert_eq(ps.Series([0, 0, None], dtype=float), 1 % self.psser) # 0.1 / True is 0.1 in pandas self.assert_eq( ps.Series([0.10000000000000009, 0.10000000000000009, None], dtype=float), 0.1 % self.psser, ) self.assertRaises(TypeError, lambda: datetime.date(1994, 1, 1) % self.psser) self.assertRaises(TypeError, lambda: True % self.psser)
def test_rfloordiv(self): if LooseVersion(pd.__version__) >= LooseVersion("0.25.3"): self.assert_eq(1 // self.pser, 1 // self.psser) self.assert_eq(0.1 // self.pser, 0.1 // self.psser) else: self.assert_eq(1 // self.psser, ps.Series([1.0, 1.0, np.inf])) self.assert_eq(0.1 // self.psser, ps.Series([0.0, 0.0, np.inf])) self.assertRaises(TypeError, lambda: "x" // self.psser) self.assertRaises(TypeError, lambda: True // self.psser) self.assertRaises(TypeError, lambda: datetime.date(1994, 1, 1) // self.psser) self.assertRaises(TypeError, lambda: datetime.datetime(1994, 1, 1) // self.psser)
def test_rmul(self): self.assert_eq((1 * self.pser).astype(float), 1 * self.psser) self.assert_eq((0.1 * self.pser).astype(float), 0.1 * self.psser) self.assertRaises(TypeError, lambda: "x" * self.psser) # In pandas, NA & False is NA, whereas NA & False is False in pandas-on-Spark if LooseVersion(pd.__version__) >= LooseVersion("1.2.2"): self.assert_eq(True * self.pser, True * self.psser) self.assert_eq(ps.Series([False, False, False], dtype="boolean"), False * self.psser) else: # Due to https://github.com/pandas-dev/pandas/issues/39410 self.assert_eq(ps.Series([False, False, False]), (False * self.psser).astype(bool)) self.assertRaises(TypeError, lambda: datetime.date(1994, 1, 1) * self.psser) self.assertRaises(TypeError, lambda: datetime.datetime(1994, 1, 1) * self.psser)
def test_get_dummies(self): for pdf_or_ps in [ pd.Series([1, 1, 1, 2, 2, 1, 3, 4]), # pd.Series([1, 1, 1, 2, 2, 1, 3, 4], dtype='category'), # pd.Series(pd.Categorical([1, 1, 1, 2, 2, 1, 3, 4], # categories=[4, 3, 2, 1])), pd.DataFrame({ "a": [1, 2, 3, 4, 4, 3, 2, 1], # 'b': pd.Categorical(list('abcdabcd')), "b": list("abcdabcd"), }), pd.DataFrame({ 10: [1, 2, 3, 4, 4, 3, 2, 1], 20: list("abcdabcd") }), ]: psdf_or_psser = ps.from_pandas(pdf_or_ps) self.assert_eq(ps.get_dummies(psdf_or_psser), pd.get_dummies(pdf_or_ps, dtype=np.int8)) psser = ps.Series([1, 1, 1, 2, 2, 1, 3, 4]) with self.assertRaisesRegex( NotImplementedError, "get_dummies currently does not support sparse"): ps.get_dummies(psser, sparse=True)
def test_accessor_works(self): register_series_accessor("test")(CustomAccessor) s = ps.Series([1, 2]) assert s.test.obj is s assert s.test.prop == "item" assert s.test.method() == "item"
def test_floordiv(self): for pser, psser in self.numeric_pser_psser_pairs: if psser.dtype == float: self.assert_eq(pser // pser, psser // psser) self.assert_eq(pser // pser.astype(bool), psser // psser.astype(bool)) self.assert_eq(pser // True, psser // True) self.assert_eq(pser // False, psser // False) with option_context("compute.ops_on_diff_frames", True): for pser, psser in self.numeric_pser_psser_pairs: self.assertRaises(TypeError, lambda: psser // self.non_numeric_pssers["string"]) self.assertRaises(TypeError, lambda: psser // self.non_numeric_pssers["datetime"]) self.assertRaises(TypeError, lambda: psser // self.non_numeric_pssers["date"]) self.assertRaises( TypeError, lambda: psser // self.non_numeric_pssers["categorical"] ) if LooseVersion(pd.__version__) >= LooseVersion("0.25.3"): self.assert_eq( (self.float_psser // self.non_numeric_pssers["bool"]).sort_index(), self.float_pser // self.non_numeric_psers["bool"], ) else: self.assert_eq( (self.float_pser // self.non_numeric_psers["bool"]).sort_index(), ps.Series([1.0, 2.0, np.inf]), )
def test_ne(self): pdf, psdf = self.pdf, self.psdf pser, psser = pdf["this_numeric_cat"], psdf["this_numeric_cat"] ordered_pser, ordered_psser = ( pdf["this_ordered_numeric_cat"], psdf["this_ordered_numeric_cat"], ) self.assert_eq(ordered_pser != 1, ordered_psser != 1) self.assert_eq(pser != pser, psser != psser) self.assert_eq(ordered_pser != ordered_pser, ordered_psser != ordered_psser) pser, psser = pdf["this_string_cat"], psdf["this_string_cat"] ordered_pser, ordered_psser = ( pdf["this_ordered_string_cat"], psdf["this_ordered_string_cat"], ) self.assert_eq(pser != "x", psser != "x") self.assert_eq(pser != pser, psser != psser) self.assert_eq(ordered_pser != ordered_pser, ordered_psser != ordered_psser) self.assertRaisesRegex( TypeError, "Cannot compare a Categorical with a scalar, which is not a category", lambda: ordered_psser != 4, ) self.assertRaisesRegex( TypeError, "Cannot compare a Categorical with a scalar, which is not a category", lambda: ordered_psser != "a", ) self.assertRaisesRegex( TypeError, "Cannot compare a Categorical with the given type", lambda: ordered_psser != ps.Series([1, 2, 3]), ) self.assertRaisesRegex( TypeError, "The operation can not be applied to list.", lambda: ordered_psser != [1, 2, 3], ) self.assert_eq( pdf["this_numeric_cat"] != pdf["that_numeric_cat"], psdf["this_numeric_cat"] != psdf["that_numeric_cat"], ) self.assert_eq( pdf["this_string_cat"] != pdf["that_string_cat"], psdf["this_string_cat"] != psdf["that_string_cat"], ) self.assert_eq( pdf["this_string_cat"] != pdf["this_given_cat_string_cat"], psdf["this_string_cat"] != psdf["this_given_cat_string_cat"], ) pser1 = pd.Series(pd.Categorical(list("abca"))) pser2 = pd.Series(pd.Categorical(list("bcaa"), categories=list("bca"))) psser1 = ps.from_pandas(pser1) psser2 = ps.from_pandas(pser2) with option_context("compute.ops_on_diff_frames", True): self.assert_eq(pser1 != pser2, (psser1 != psser2).sort_index())
def test_ge(self): ordered_pser = self.ordered_pser ordered_psser = self.ordered_psser self.assert_eq(ordered_pser >= ordered_pser, ordered_psser >= ordered_psser) with option_context("compute.ops_on_diff_frames", True): self.assert_eq( ordered_pser >= self.other_ordered_pser, ordered_psser >= self.other_ordered_psser ) self.assertRaisesRegex( TypeError, "Unordered Categoricals can only compare equality or not", lambda: self.unordered_psser >= ordered_psser, ) self.assertRaisesRegex( TypeError, "Categoricals can only be compared if 'categories' are the same", lambda: ordered_psser >= self.unordered_psser, ) self.assertRaisesRegex( TypeError, "Cannot compare a Categorical with the given type", lambda: ordered_psser >= ps.Series([1, 2, 3]), ) self.assertRaisesRegex( TypeError, "Cannot compare a Categorical with the given type", lambda: ordered_psser >= [1, 2, 3], ) self.assertRaisesRegex( TypeError, "Cannot compare a Categorical with the given type", lambda: ordered_psser >= 1, )
def test_rpow(self): self.assert_eq(1 ** self.psser, ps.Series([1, 1, 1], dtype=float)) self.assert_eq((0.1 ** self.pser).astype(float), 0.1 ** self.psser) self.assertRaises(TypeError, lambda: "x" ** self.psser) self.assertRaises(TypeError, lambda: True ** self.psser) self.assertRaises(TypeError, lambda: datetime.date(1994, 1, 1) ** self.psser) self.assertRaises(TypeError, lambda: datetime.datetime(1994, 1, 1) ** self.psser)
def test_to_timedelta(self): self.assert_eq( ps.to_timedelta("1 days 06:05:01.00003"), pd.to_timedelta("1 days 06:05:01.00003"), ) self.assert_eq( ps.to_timedelta("15.5us"), pd.to_timedelta("15.5us"), ) self.assert_eq( ps.to_timedelta(["1 days 06:05:01.00003", "15.5us", "nan"]), pd.to_timedelta(["1 days 06:05:01.00003", "15.5us", "nan"]), ) self.assert_eq( ps.to_timedelta(np.arange(5), unit="s"), pd.to_timedelta(np.arange(5), unit="s"), ) self.assert_eq( ps.to_timedelta(ps.Series([1, 2]), unit="d"), pd.to_timedelta(pd.Series([1, 2]), unit="d"), ) self.assert_eq( ps.to_timedelta(pd.Series([1, 2]), unit="d"), pd.to_timedelta(pd.Series([1, 2]), unit="d"), )
def test_from_to_pandas(self): sparse_values = {0: 0.1, 1: 1.1} sparse_vector = SparseVector(len(sparse_values), sparse_values) pser = pd.Series([sparse_vector]) psser = ps.Series([sparse_vector]) self.assert_eq(pser, psser.to_pandas()) self.assert_eq(ps.from_pandas(pser), psser)
def test_groupby_expanding_count(self): # The behaviour of ExpandingGroupby.count are different between pandas>=1.0.0 and lower, # and we're following the behaviour of latest version of pandas. if LooseVersion(pd.__version__) >= LooseVersion("1.0.0"): self._test_groupby_expanding_func("count") else: # Series psser = ps.Series([1, 2, 3]) kkey = ps.Series([1, 2, 3], name="a") midx = pd.MultiIndex.from_tuples( list( zip(kkey.to_pandas().values, psser.index.to_pandas().values)), names=["a", None], ) expected_result = pd.Series([np.nan, np.nan, np.nan], index=midx) self.assert_eq( psser.groupby(kkey).expanding(2).count().sort_index(), expected_result.sort_index()) # DataFrame psdf = ps.DataFrame({"a": [1, 2, 3, 2], "b": [4.0, 2.0, 3.0, 1.0]}) kkey = ps.Series([1, 2, 3, 2], name="a") midx = pd.MultiIndex.from_tuples([(1, 0), (2, 1), (2, 3), (3, 2)], names=["a", None]) expected_result = pd.DataFrame( { "a": [None, None, 2.0, None], "b": [None, None, 2.0, None] }, index=midx) self.assert_eq( psdf.groupby(kkey).expanding(2).count().sort_index(), expected_result.sort_index()) expected_result = pd.Series([None, None, 2.0, None], index=midx, name="b") self.assert_eq( psdf.groupby(kkey)["b"].expanding(2).count().sort_index(), expected_result.sort_index(), ) expected_result = pd.DataFrame({"b": [None, None, 2.0, None]}, index=midx) self.assert_eq( psdf.groupby(kkey)[["b"]].expanding(2).count().sort_index(), expected_result.sort_index(), )
def test_categorical_series(self): pser = pd.Series([1, 2, 3], dtype="category") kser = ps.Series([1, 2, 3], dtype="category") self.assert_eq(kser, pser) self.assert_eq(kser.cat.categories, pser.cat.categories) self.assert_eq(kser.cat.codes, pser.cat.codes) self.assert_eq(kser.cat.ordered, pser.cat.ordered)
def complex_psdf(self): pssers = { "this_array": self.psser, "that_array": ps.Series([[2, 3, 4]]), "this_struct": ps.Index([("x", 1)]).to_series().reset_index(drop=True), "that_struct": ps.Index([("a", 2)]).to_series().reset_index(drop=True), } return ps.concat(pssers, axis=1)
def test_from_to_pandas(self): data = [0.1, 0.2, 0.3, None] dtypes = ["Float32", "Float64"] for dtype in dtypes: pser = pd.Series(data, dtype=dtype) psser = ps.Series(data, dtype=dtype) self.check_extension(pser, psser.to_pandas()) self.check_extension(ps.from_pandas(pser), psser)
def test_from_to_pandas(self): data = [1, 2, 3, None] dtypes = ["Int8", "Int16", "Int32", "Int64"] for dtype in dtypes: pser = pd.Series(data, dtype=dtype) psser = ps.Series(data, dtype=dtype) self.check_extension(pser, psser.to_pandas()) self.check_extension(ps.from_pandas(pser), psser)
def test_raises_attr_error(self): with ensure_removed(ps.Series, "bad"): class Bad: def __init__(self, data): raise AttributeError("whoops") with self.assertRaises(AttributeError): ps.Series([1, 2], dtype=object).bad
def test_multiindex_transform_negative(self): with self.assertRaisesRegex( NotImplementedError, "MultiIndex does not support spark.transform yet" ): midx = pd.MultiIndex( [["lama", "cow", "falcon"], ["speed", "weight", "length"]], [[0, 0, 0, 1, 1, 1, 2, 2, 2], [1, 1, 1, 1, 1, 2, 1, 2, 2]], ) s = ps.Series([45, 200, 1.2, 30, 250, 1.5, 320, 1, 0.3], index=midx) s.index.spark.transform(lambda scol: scol)
def test_from_to_pandas(self): data = [ datetime.date(1994, 1, 31), datetime.date(1994, 2, 1), datetime.date(1994, 2, 2) ] pser = pd.Series(data) psser = ps.Series(data) self.assert_eq(pser, psser.to_pandas()) self.assert_eq(ps.from_pandas(pser), psser)
def test_radd(self): self.assert_eq((1 + self.pser).astype(float), 1 + self.psser) self.assert_eq((0.1 + self.pser).astype(float), 0.1 + self.psser) self.assertRaises(TypeError, lambda: "x" + self.psser) # In pandas, NA | True is NA, whereas NA | True is True in pandas-on-Spark self.check_extension(ps.Series([True, True, True], dtype="boolean"), True + self.psser) self.check_extension(False + self.pser, False + self.psser) self.assertRaises(TypeError, lambda: datetime.date(1994, 1, 1) + self.psser) self.assertRaises(TypeError, lambda: datetime.datetime(1994, 1, 1) + self.psser)
def test_rmul(self): self.assert_eq((1 * self.pser).astype(float), 1 * self.psser) self.assert_eq((0.1 * self.pser).astype(float), 0.1 * self.psser) self.assertRaises(TypeError, lambda: "x" * self.psser) # In pandas, NA & False is NA, whereas NA & False is False in pandas-on-Spark self.check_extension(True * self.pser, True * self.psser) self.check_extension(ps.Series([False, False, False], dtype="boolean"), False * self.psser) self.assertRaises(TypeError, lambda: datetime.date(1994, 1, 1) * self.psser) self.assertRaises(TypeError, lambda: datetime.datetime(1994, 1, 1) * self.psser)
def test_eq(self): pdf, psdf = self.pdf, self.psdf pser, psser = pdf["this_numeric_cat"], psdf["this_numeric_cat"] ordered_pser, ordered_psser = ( pdf["this_ordered_numeric_cat"], psdf["this_ordered_numeric_cat"], ) self.assert_eq(ordered_pser == 1, ordered_psser == 1) self.assert_eq(pser == pser, psser == psser) self.assert_eq(ordered_pser == ordered_pser, ordered_psser == ordered_psser) pser, psser = pdf["this_string_cat"], psdf["this_string_cat"] ordered_pser, ordered_psser = ( pdf["this_ordered_string_cat"], psdf["this_ordered_string_cat"], ) self.assert_eq(pser == "x", psser == "x") self.assert_eq(pser == pser, psser == psser) self.assert_eq(ordered_pser == ordered_pser, ordered_psser == ordered_psser) self.assertRaisesRegex( TypeError, "Cannot compare a Categorical with a scalar, which is not a category", lambda: ordered_psser == 4, ) self.assertRaisesRegex( TypeError, "Cannot compare a Categorical with a scalar, which is not a category", lambda: ordered_psser == "a", ) self.assertRaisesRegex( TypeError, "Cannot compare a Categorical with the given type", lambda: ordered_psser == ps.Series([1, 2, 3]), ) self.assertRaisesRegex( TypeError, "Cannot compare a Categorical with the given type", lambda: ordered_psser == [1, 2, 3], ) self.assert_eq( pdf["this_numeric_cat"] == pdf["that_numeric_cat"], psdf["this_numeric_cat"] == psdf["that_numeric_cat"], ) self.assert_eq( pdf["this_string_cat"] == pdf["that_string_cat"], psdf["this_string_cat"] == psdf["that_string_cat"], )
def test_lt(self): pdf, psdf = self.pdf, self.psdf ordered_pser, ordered_psser = ( pdf["this_ordered_numeric_cat"], psdf["this_ordered_numeric_cat"], ) self.assert_eq(ordered_pser < 1, ordered_psser < 1) self.assert_eq(ordered_pser < ordered_pser, ordered_psser < ordered_psser) ordered_pser, ordered_psser = ( pdf["this_ordered_string_cat"], psdf["this_ordered_string_cat"], ) self.assert_eq(ordered_pser < "x", ordered_psser < "x") self.assert_eq(ordered_pser < ordered_pser, ordered_psser < ordered_psser) self.assertRaisesRegex( TypeError, "Unordered Categoricals can only compare equality or not", lambda: self.psser < ordered_psser, ) self.assertRaisesRegex( TypeError, "Cannot compare a Categorical with a scalar, which is not a category", lambda: ordered_psser < 4, ) self.assertRaisesRegex( TypeError, "Cannot compare a Categorical with a scalar, which is not a category", lambda: ordered_psser < "a", ) self.assertRaisesRegex( TypeError, "Cannot compare a Categorical with the given type", lambda: ordered_psser < ps.Series([1, 2, 3]), ) self.assertRaisesRegex( TypeError, "The operation can not be applied to list", lambda: ordered_psser < [1, 2, 3], ) self.assert_eq( pdf["this_ordered_numeric_cat"] < pdf["that_ordered_numeric_cat"], psdf["this_ordered_numeric_cat"] < psdf["that_ordered_numeric_cat"], ) self.assert_eq( pdf["this_ordered_string_cat"] < pdf["that_ordered_string_cat"], psdf["this_ordered_string_cat"] < psdf["that_ordered_string_cat"], )
def test_mul(self): self.assertRaises(TypeError, lambda: self.psser * "x") self.assert_eq(self.pser * 1, self.psser * 1) with option_context("compute.ops_on_diff_frames", True): for pser, psser in self.pser_psser_pairs: if psser.dtype in [np.int32, np.int64]: self.assert_eq( ps.Series(["x", "yy", "zzz", None]).astype("string"), (self.psser * psser).sort_index(), ) else: self.assertRaises(TypeError, lambda: self.psser * psser)