def test_array(self, all_compare_operators): op = self.get_op_from_name(all_compare_operators) a = pd.array([True] * 3 + [False] * 3 + [None] * 3, dtype="boolean") b = pd.array([True, False, None] * 3, dtype="boolean") result = op(a, b) values = op(a._data, b._data) mask = a._mask | b._mask expected = BooleanArray(values, mask) tm.assert_extension_array_equal(result, expected) # ensure we haven't mutated anything inplace result[0] = None tm.assert_extension_array_equal( a, pd.array([True] * 3 + [False] * 3 + [None] * 3, dtype="boolean")) tm.assert_extension_array_equal( b, pd.array([True, False, None] * 3, dtype="boolean"))
def test_array(self, comparison_op, dtype): op = comparison_op left = pd.array([0, 1, 2, None, None, None], dtype=dtype) right = pd.array([0, 1, None, 0, 1, None], dtype=dtype) result = op(left, right) values = op(left._data, right._data) mask = left._mask | right._mask expected = pd.arrays.BooleanArray(values, mask) tm.assert_extension_array_equal(result, expected) # ensure we haven't mutated anything inplace result[0] = pd.NA tm.assert_extension_array_equal( left, pd.array([0, 1, 2, None, None, None], dtype=dtype)) tm.assert_extension_array_equal( right, pd.array([0, 1, None, 0, 1, None], dtype=dtype))
def test_array(self, all_compare_operators): op = self.get_op_from_name(all_compare_operators) a = pd.array([0, 1, 2, None, None, None], dtype="Int64") b = pd.array([0, 1, None, 0, 1, None], dtype="Int64") result = op(a, b) values = op(a._data, b._data) mask = a._mask | b._mask expected = pd.arrays.BooleanArray(values, mask) tm.assert_extension_array_equal(result, expected) # ensure we haven't mutated anything inplace result[0] = pd.NA tm.assert_extension_array_equal( a, pd.array([0, 1, 2, None, None, None], dtype="Int64") ) tm.assert_extension_array_equal( b, pd.array([0, 1, None, 0, 1, None], dtype="Int64") )
def test_astype_nullable_int(dtype): arr = pd.array(["1", pd.NA, "3"], dtype=dtype) result = arr.astype("Int64") expected = pd.array([1, pd.NA, 3], dtype="Int64") tm.assert_extension_array_equal(result, expected)
def test_comparison_methods_scalar_pd_na(comparison_op, dtype): op_name = f"__{comparison_op.__name__}__" a = pd.array(["a", None, "c"], dtype=dtype) result = getattr(a, op_name)(pd.NA) expected = pd.array([None, None, None], dtype="boolean") tm.assert_extension_array_equal(result, expected)
def test_to_boolean_array_missing_indicators(a, b): result = pd.array(a, dtype="boolean") expected = pd.array(b, dtype="boolean") tm.assert_extension_array_equal(result, expected)
def test_numpy_array(arr): ser = pd.Series(arr) result = ser.array expected = PandasArray(arr) tm.assert_extension_array_equal(result, expected)
def test_value_counts_unique_nunique_null(self, null_obj, index_or_series_obj): orig = index_or_series_obj obj = orig.copy() klass = type(obj) values = obj._ndarray_values num_values = len(orig) if not allow_na_ops(obj): pytest.skip("type doesn't allow for NA operations") elif isinstance(orig, (pd.CategoricalIndex, pd.IntervalIndex)): pytest.skip(f"values of {klass} cannot be changed") elif isinstance(orig, pd.MultiIndex): pytest.skip("MultiIndex doesn't support isna") elif orig.duplicated().any(): pytest.xfail( "The test implementation isn't flexible enough to deal " "with duplicated values. This isn't a bug in the " "application code, but in the test code.") # special assign to the numpy array if is_datetime64tz_dtype(obj): if isinstance(obj, DatetimeIndex): v = obj.asi8 v[0:2] = iNaT values = obj._shallow_copy(v) else: obj = obj.copy() obj[0:2] = pd.NaT values = obj._values elif needs_i8_conversion(obj): values[0:2] = iNaT values = obj._shallow_copy(values) else: values[0:2] = null_obj # check values has the same dtype as the original assert values.dtype == obj.dtype # create repeated values, 'n'th element is repeated by n+1 # times if isinstance(obj, (DatetimeIndex, PeriodIndex)): expected_index = obj.copy() expected_index.name = None # attach name to klass obj = klass(values.repeat(range(1, len(obj) + 1))) obj.name = "a" else: if isinstance(obj, DatetimeIndex): expected_index = orig._values._shallow_copy(values) else: expected_index = Index(values) expected_index.name = None obj = obj.repeat(range(1, len(obj) + 1)) obj.name = "a" # check values has the same dtype as the original assert obj.dtype == orig.dtype # check values correctly have NaN nanloc = np.zeros(len(obj), dtype=np.bool) nanloc[:3] = True if isinstance(obj, Index): tm.assert_numpy_array_equal(pd.isna(obj), nanloc) else: exp = Series(nanloc, obj.index, name="a") tm.assert_series_equal(pd.isna(obj), exp) expected_data = list(range(num_values, 2, -1)) expected_data_na = expected_data.copy() if expected_data_na: expected_data_na.append(3) expected_s_na = Series( expected_data_na, index=expected_index[num_values - 1:0:-1], dtype="int64", name="a", ) expected_s = Series( expected_data, index=expected_index[num_values - 1:1:-1], dtype="int64", name="a", ) result_s_na = obj.value_counts(dropna=False) tm.assert_series_equal(result_s_na, expected_s_na) assert result_s_na.index.name is None assert result_s_na.name == "a" result_s = obj.value_counts() tm.assert_series_equal(obj.value_counts(), expected_s) assert result_s.index.name is None assert result_s.name == "a" result = obj.unique() if isinstance(obj, Index): tm.assert_index_equal(result, Index(values[1:], name="a")) elif is_datetime64tz_dtype(obj): # unable to compare NaT / nan tm.assert_extension_array_equal(result[1:], values[2:]) assert result[0] is pd.NaT elif len(obj) > 0: tm.assert_numpy_array_equal(result[1:], values[2:]) assert pd.isna(result[0]) assert result.dtype == orig.dtype assert obj.nunique() == max(0, num_values - 2) assert obj.nunique(dropna=False) == max(0, num_values - 1)
def test_add_mul(left_array, right_array, opname, exp): op = getattr(operator, opname) result = op(left_array, right_array) expected = pd.array(exp, dtype="boolean") tm.assert_extension_array_equal(result, expected)
def test_pow_array(): a = integer_array([0, 0, 0, 1, 1, 1, None, None, None]) b = integer_array([0, 1, None, 0, 1, None, 0, 1, None]) result = a ** b expected = integer_array([1, 0, None, 1, 1, 1, 1, None, None]) tm.assert_extension_array_equal(result, expected)
def test_array_inference_fails(data): result = pd.array(data) expected = PandasArray(np.array(data, dtype=object)) tm.assert_extension_array_equal(result, expected)
def test_set_closed(self, closed, new_closed): # GH 21670 array = IntervalArray.from_breaks(range(10), closed=closed) result = array.set_closed(new_closed) expected = IntervalArray.from_breaks(range(10), closed=new_closed) tm.assert_extension_array_equal(result, expected)
def test_astype_boolean(): # https://github.com/pandas-dev/pandas/issues/31102 a = pd.array([1, 0, -1, 2, None], dtype="Int64") result = a.astype("boolean") expected = pd.array([True, False, True, True, None], dtype="boolean") tm.assert_extension_array_equal(result, expected)
def test_astype_floating(): arr = pd.array([1, 2, None], dtype="Int64") result = arr.astype("Float64") expected = pd.array([1.0, 2.0, None], dtype="Float64") tm.assert_extension_array_equal(result, expected)
def test_pow_array(dtype): a = pd.array([0, 0, 0, 1, 1, 1, None, None, None], dtype=dtype) b = pd.array([0, 1, None, 0, 1, None, 0, 1, None], dtype=dtype) result = a**b expected = pd.array([1, 0, None, 1, 1, 1, 1, None, None], dtype=dtype) tm.assert_extension_array_equal(result, expected)
def test_to_integer_array_bool(constructor, bool_values, int_values, target_dtype, expected_dtype): result = constructor(bool_values, dtype=target_dtype) assert result.dtype == expected_dtype expected = pd.array(int_values, dtype=target_dtype) tm.assert_extension_array_equal(result, expected)
def test_to_integer_array(values, to_dtype, result_dtype): # convert existing arrays to IntegerArrays result = IntegerArray._from_sequence(values, dtype=to_dtype) assert result.dtype == result_dtype() expected = pd.array(values, dtype=result_dtype()) tm.assert_extension_array_equal(result, expected)
def test_unary_minus_nullable_int(any_signed_nullable_int_dtype, source, target): dtype = any_signed_nullable_int_dtype arr = pd.array(source, dtype=dtype) result = -arr expected = pd.array(target, dtype=dtype) tm.assert_extension_array_equal(result, expected)
def test_op_int8(left_array, right_array, opname): op = getattr(operator, opname) result = op(left_array, right_array) expected = op(left_array.astype("Int8"), right_array.astype("Int8")) tm.assert_extension_array_equal(result, expected)
def test_unary_plus_nullable_int(any_signed_nullable_int_dtype, source): dtype = any_signed_nullable_int_dtype expected = pd.array(source, dtype=dtype) result = +expected tm.assert_extension_array_equal(result, expected)
def test_array_ufunc(): a = to_decimal([1, 2, 3]) result = np.exp(a) expected = to_decimal(np.exp(a._data)) tm.assert_extension_array_equal(result, expected)
def test_abs_nullable_int(any_signed_nullable_int_dtype, source, target): dtype = any_signed_nullable_int_dtype s = pd.array(source, dtype=dtype) result = abs(s) expected = pd.array(target, dtype=dtype) tm.assert_extension_array_equal(result, expected)
def test_numpy_scalars_ok(self, all_logical_operators): a = pd.array([True, False, None], dtype="boolean") op = getattr(a, all_logical_operators) tm.assert_extension_array_equal(op(True), op(np.bool_(True))) tm.assert_extension_array_equal(op(False), op(np.bool_(False)))
def test_pow_scalar(): a = pd.array([-1, 0, 1, None, 2], dtype="Int64") result = a ** 0 expected = pd.array([1, 1, 1, 1, 1], dtype="Int64") tm.assert_extension_array_equal(result, expected) result = a ** 1 expected = pd.array([-1, 0, 1, None, 2], dtype="Int64") tm.assert_extension_array_equal(result, expected) result = a ** pd.NA expected = pd.array([None, None, 1, None, None], dtype="Int64") tm.assert_extension_array_equal(result, expected) result = a ** np.nan expected = np.array([np.nan, np.nan, 1, np.nan, np.nan], dtype="float64") tm.assert_numpy_array_equal(result, expected) # reversed a = a[1:] # Can't raise integers to negative powers. result = 0 ** a expected = pd.array([1, 0, None, 0], dtype="Int64") tm.assert_extension_array_equal(result, expected) result = 1 ** a expected = pd.array([1, 1, 1, 1], dtype="Int64") tm.assert_extension_array_equal(result, expected) result = pd.NA ** a expected = pd.array([1, None, None, None], dtype="Int64") tm.assert_extension_array_equal(result, expected) result = np.nan ** a expected = np.array([1, np.nan, np.nan, np.nan], dtype="float64") tm.assert_numpy_array_equal(result, expected)
def test_downcast_nullable_numeric(data, input_dtype, downcast, expected_dtype): arr = pd.array(data, dtype=input_dtype) result = to_numeric(arr, downcast=downcast) expected = pd.array(data, dtype=expected_dtype) tm.assert_extension_array_equal(result, expected)
def test_to_array_bool(bool_values, values, target_dtype, expected_dtype): result = pd.array(bool_values, dtype=target_dtype) assert result.dtype == expected_dtype expected = pd.array(values, dtype=target_dtype) tm.assert_extension_array_equal(result, expected)
def test_constructor_nan_like(na): expected = pd.arrays.StringArray(np.array(["a", pd.NA])) tm.assert_extension_array_equal( pd.arrays.StringArray(np.array(["a", na], dtype="object")), expected)
def test_to_array(): result = pd.array([0.1, 0.2, 0.3, 0.4]) expected = pd.array([0.1, 0.2, 0.3, 0.4], dtype="Float64") tm.assert_extension_array_equal(result, expected)
def test_comparison_methods_scalar_pd_na(all_compare_operators, dtype): op_name = all_compare_operators a = pd.array(["a", None, "c"], dtype=dtype) result = getattr(a, op_name)(pd.NA) expected = pd.array([None, None, None], dtype="boolean") tm.assert_extension_array_equal(result, expected)
def test_to_integer_array_none_is_nan(a, b): result = pd.array(a, dtype="Int64") expected = pd.array(b, dtype="Int64") tm.assert_extension_array_equal(result, expected)