8th day of python challenges 111-117
This commit is contained in:
abd.shallal
@@ -0,0 +1,392 @@
|
||||
import numpy as np
|
||||
import pytest
|
||||
|
||||
from pandas.compat.numpy import _np_version_under1p16
|
||||
|
||||
import pandas as pd
|
||||
from pandas.core.arrays.numpy_ import PandasArray, PandasDtype
|
||||
import pandas.util.testing as tm
|
||||
|
||||
from . import base
|
||||
|
||||
|
||||
@pytest.fixture(params=["float", "object"])
|
||||
def dtype(request):
|
||||
return PandasDtype(np.dtype(request.param))
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def allow_in_pandas(monkeypatch):
|
||||
"""
|
||||
A monkeypatch to tells pandas to let us in.
|
||||
|
||||
By default, passing a PandasArray to an index / series / frame
|
||||
constructor will unbox that PandasArray to an ndarray, and treat
|
||||
it as a non-EA column. We don't want people using EAs without
|
||||
reason.
|
||||
|
||||
The mechanism for this is a check against ABCPandasArray
|
||||
in each constructor.
|
||||
|
||||
But, for testing, we need to allow them in pandas. So we patch
|
||||
the _typ of PandasArray, so that we evade the ABCPandasArray
|
||||
check.
|
||||
"""
|
||||
with monkeypatch.context() as m:
|
||||
m.setattr(PandasArray, "_typ", "extension")
|
||||
yield
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def data(allow_in_pandas, dtype):
|
||||
if dtype.numpy_dtype == "object":
|
||||
return pd.Series([(i,) for i in range(100)]).array
|
||||
return PandasArray(np.arange(1, 101, dtype=dtype._dtype))
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def data_missing(allow_in_pandas, dtype):
|
||||
# For NumPy <1.16, np.array([np.nan, (1,)]) raises
|
||||
# ValueError: setting an array element with a sequence.
|
||||
if dtype.numpy_dtype == "object":
|
||||
if _np_version_under1p16:
|
||||
raise pytest.skip("Skipping for NumPy <1.16")
|
||||
return PandasArray(np.array([np.nan, (1,)]))
|
||||
return PandasArray(np.array([np.nan, 1.0]))
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def na_value():
|
||||
return np.nan
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def na_cmp():
|
||||
def cmp(a, b):
|
||||
return np.isnan(a) and np.isnan(b)
|
||||
|
||||
return cmp
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def data_for_sorting(allow_in_pandas, dtype):
|
||||
"""Length-3 array with a known sort order.
|
||||
|
||||
This should be three items [B, C, A] with
|
||||
A < B < C
|
||||
"""
|
||||
if dtype.numpy_dtype == "object":
|
||||
# Use an empty tuple for first element, then remove,
|
||||
# to disable np.array's shape inference.
|
||||
return PandasArray(np.array([(), (2,), (3,), (1,)])[1:])
|
||||
return PandasArray(np.array([1, 2, 0]))
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def data_missing_for_sorting(allow_in_pandas, dtype):
|
||||
"""Length-3 array with a known sort order.
|
||||
|
||||
This should be three items [B, NA, A] with
|
||||
A < B and NA missing.
|
||||
"""
|
||||
if dtype.numpy_dtype == "object":
|
||||
return PandasArray(np.array([(1,), np.nan, (0,)]))
|
||||
return PandasArray(np.array([1, np.nan, 0]))
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def data_for_grouping(allow_in_pandas, dtype):
|
||||
"""Data for factorization, grouping, and unique tests.
|
||||
|
||||
Expected to be like [B, B, NA, NA, A, A, B, C]
|
||||
|
||||
Where A < B < C and NA is missing
|
||||
"""
|
||||
if dtype.numpy_dtype == "object":
|
||||
a, b, c = (1,), (2,), (3,)
|
||||
else:
|
||||
a, b, c = np.arange(3)
|
||||
return PandasArray(np.array([b, b, np.nan, np.nan, a, a, b, c]))
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def skip_numpy_object(dtype):
|
||||
"""
|
||||
Tests for PandasArray with nested data. Users typically won't create
|
||||
these objects via `pd.array`, but they can show up through `.array`
|
||||
on a Series with nested data. Many of the base tests fail, as they aren't
|
||||
appropriate for nested data.
|
||||
|
||||
This fixture allows these tests to be skipped when used as a usefixtures
|
||||
marker to either an individual test or a test class.
|
||||
"""
|
||||
if dtype == "object":
|
||||
raise pytest.skip("Skipping for object dtype.")
|
||||
|
||||
|
||||
skip_nested = pytest.mark.usefixtures("skip_numpy_object")
|
||||
|
||||
|
||||
class BaseNumPyTests:
|
||||
pass
|
||||
|
||||
|
||||
class TestCasting(BaseNumPyTests, base.BaseCastingTests):
|
||||
@skip_nested
|
||||
def test_astype_str(self, data):
|
||||
# ValueError: setting an array element with a sequence
|
||||
super().test_astype_str(data)
|
||||
|
||||
|
||||
class TestConstructors(BaseNumPyTests, base.BaseConstructorsTests):
|
||||
@pytest.mark.skip(reason="We don't register our dtype")
|
||||
# We don't want to register. This test should probably be split in two.
|
||||
def test_from_dtype(self, data):
|
||||
pass
|
||||
|
||||
@skip_nested
|
||||
def test_array_from_scalars(self, data):
|
||||
# ValueError: PandasArray must be 1-dimensional.
|
||||
super().test_array_from_scalars(data)
|
||||
|
||||
|
||||
class TestDtype(BaseNumPyTests, base.BaseDtypeTests):
|
||||
@pytest.mark.skip(reason="Incorrect expected.")
|
||||
# we unsurprisingly clash with a NumPy name.
|
||||
def test_check_dtype(self, data):
|
||||
pass
|
||||
|
||||
|
||||
class TestGetitem(BaseNumPyTests, base.BaseGetitemTests):
|
||||
@skip_nested
|
||||
def test_getitem_scalar(self, data):
|
||||
# AssertionError
|
||||
super().test_getitem_scalar(data)
|
||||
|
||||
@skip_nested
|
||||
def test_take_series(self, data):
|
||||
# ValueError: PandasArray must be 1-dimensional.
|
||||
super().test_take_series(data)
|
||||
|
||||
@pytest.mark.xfail(reason="astype doesn't recognize data.dtype")
|
||||
def test_loc_iloc_frame_single_dtype(self, data):
|
||||
super().test_loc_iloc_frame_single_dtype(data)
|
||||
|
||||
|
||||
class TestGroupby(BaseNumPyTests, base.BaseGroupbyTests):
|
||||
@skip_nested
|
||||
def test_groupby_extension_apply(self, data_for_grouping, groupby_apply_op):
|
||||
# ValueError: Names should be list-like for a MultiIndex
|
||||
super().test_groupby_extension_apply(data_for_grouping, groupby_apply_op)
|
||||
|
||||
|
||||
class TestInterface(BaseNumPyTests, base.BaseInterfaceTests):
|
||||
@skip_nested
|
||||
def test_array_interface(self, data):
|
||||
# NumPy array shape inference
|
||||
super().test_array_interface(data)
|
||||
|
||||
|
||||
class TestMethods(BaseNumPyTests, base.BaseMethodsTests):
|
||||
@pytest.mark.skip(reason="TODO: remove?")
|
||||
def test_value_counts(self, all_data, dropna):
|
||||
pass
|
||||
|
||||
@pytest.mark.skip(reason="Incorrect expected")
|
||||
# We have a bool dtype, so the result is an ExtensionArray
|
||||
# but expected is not
|
||||
def test_combine_le(self, data_repeated):
|
||||
super().test_combine_le(data_repeated)
|
||||
|
||||
@skip_nested
|
||||
def test_combine_add(self, data_repeated):
|
||||
# Not numeric
|
||||
super().test_combine_add(data_repeated)
|
||||
|
||||
@skip_nested
|
||||
def test_shift_fill_value(self, data):
|
||||
# np.array shape inference. Shift implementation fails.
|
||||
super().test_shift_fill_value(data)
|
||||
|
||||
@skip_nested
|
||||
@pytest.mark.parametrize("box", [pd.Series, lambda x: x])
|
||||
@pytest.mark.parametrize("method", [lambda x: x.unique(), pd.unique])
|
||||
def test_unique(self, data, box, method):
|
||||
# Fails creating expected
|
||||
super().test_unique(data, box, method)
|
||||
|
||||
@skip_nested
|
||||
def test_fillna_copy_frame(self, data_missing):
|
||||
# The "scalar" for this array isn't a scalar.
|
||||
super().test_fillna_copy_frame(data_missing)
|
||||
|
||||
@skip_nested
|
||||
def test_fillna_copy_series(self, data_missing):
|
||||
# The "scalar" for this array isn't a scalar.
|
||||
super().test_fillna_copy_series(data_missing)
|
||||
|
||||
@skip_nested
|
||||
def test_hash_pandas_object_works(self, data, as_frame):
|
||||
# ndarray of tuples not hashable
|
||||
super().test_hash_pandas_object_works(data, as_frame)
|
||||
|
||||
@skip_nested
|
||||
def test_searchsorted(self, data_for_sorting, as_series):
|
||||
# Test setup fails.
|
||||
super().test_searchsorted(data_for_sorting, as_series)
|
||||
|
||||
@skip_nested
|
||||
def test_where_series(self, data, na_value, as_frame):
|
||||
# Test setup fails.
|
||||
super().test_where_series(data, na_value, as_frame)
|
||||
|
||||
@skip_nested
|
||||
@pytest.mark.parametrize("repeats", [0, 1, 2, [1, 2, 3]])
|
||||
def test_repeat(self, data, repeats, as_series, use_numpy):
|
||||
# Fails creating expected
|
||||
super().test_repeat(data, repeats, as_series, use_numpy)
|
||||
|
||||
|
||||
@skip_nested
|
||||
class TestArithmetics(BaseNumPyTests, base.BaseArithmeticOpsTests):
|
||||
divmod_exc = None
|
||||
series_scalar_exc = None
|
||||
frame_scalar_exc = None
|
||||
series_array_exc = None
|
||||
|
||||
def test_divmod_series_array(self, data):
|
||||
s = pd.Series(data)
|
||||
self._check_divmod_op(s, divmod, data, exc=None)
|
||||
|
||||
@pytest.mark.skip("We implement ops")
|
||||
def test_error(self, data, all_arithmetic_operators):
|
||||
pass
|
||||
|
||||
def test_arith_series_with_scalar(self, data, all_arithmetic_operators):
|
||||
super().test_arith_series_with_scalar(data, all_arithmetic_operators)
|
||||
|
||||
def test_arith_series_with_array(self, data, all_arithmetic_operators):
|
||||
super().test_arith_series_with_array(data, all_arithmetic_operators)
|
||||
|
||||
|
||||
class TestPrinting(BaseNumPyTests, base.BasePrintingTests):
|
||||
pass
|
||||
|
||||
|
||||
@skip_nested
|
||||
class TestNumericReduce(BaseNumPyTests, base.BaseNumericReduceTests):
|
||||
def check_reduce(self, s, op_name, skipna):
|
||||
result = getattr(s, op_name)(skipna=skipna)
|
||||
# avoid coercing int -> float. Just cast to the actual numpy type.
|
||||
expected = getattr(s.astype(s.dtype._dtype), op_name)(skipna=skipna)
|
||||
tm.assert_almost_equal(result, expected)
|
||||
|
||||
|
||||
@skip_nested
|
||||
class TestBooleanReduce(BaseNumPyTests, base.BaseBooleanReduceTests):
|
||||
pass
|
||||
|
||||
|
||||
class TestMissing(BaseNumPyTests, base.BaseMissingTests):
|
||||
@skip_nested
|
||||
def test_fillna_scalar(self, data_missing):
|
||||
# Non-scalar "scalar" values.
|
||||
super().test_fillna_scalar(data_missing)
|
||||
|
||||
@skip_nested
|
||||
def test_fillna_series_method(self, data_missing, fillna_method):
|
||||
# Non-scalar "scalar" values.
|
||||
super().test_fillna_series_method(data_missing, fillna_method)
|
||||
|
||||
@skip_nested
|
||||
def test_fillna_series(self, data_missing):
|
||||
# Non-scalar "scalar" values.
|
||||
super().test_fillna_series(data_missing)
|
||||
|
||||
@skip_nested
|
||||
def test_fillna_frame(self, data_missing):
|
||||
# Non-scalar "scalar" values.
|
||||
super().test_fillna_frame(data_missing)
|
||||
|
||||
|
||||
class TestReshaping(BaseNumPyTests, base.BaseReshapingTests):
|
||||
@pytest.mark.skip("Incorrect parent test")
|
||||
# not actually a mixed concat, since we concat int and int.
|
||||
def test_concat_mixed_dtypes(self, data):
|
||||
super().test_concat_mixed_dtypes(data)
|
||||
|
||||
@skip_nested
|
||||
def test_merge(self, data, na_value):
|
||||
# Fails creating expected
|
||||
super().test_merge(data, na_value)
|
||||
|
||||
@skip_nested
|
||||
def test_merge_on_extension_array(self, data):
|
||||
# Fails creating expected
|
||||
super().test_merge_on_extension_array(data)
|
||||
|
||||
@skip_nested
|
||||
def test_merge_on_extension_array_duplicates(self, data):
|
||||
# Fails creating expected
|
||||
super().test_merge_on_extension_array_duplicates(data)
|
||||
|
||||
|
||||
class TestSetitem(BaseNumPyTests, base.BaseSetitemTests):
|
||||
@skip_nested
|
||||
def test_setitem_scalar_series(self, data, box_in_series):
|
||||
# AssertionError
|
||||
super().test_setitem_scalar_series(data, box_in_series)
|
||||
|
||||
@skip_nested
|
||||
def test_setitem_sequence(self, data, box_in_series):
|
||||
# ValueError: shape mismatch: value array of shape (2,1) could not
|
||||
# be broadcast to indexing result of shape (2,)
|
||||
super().test_setitem_sequence(data, box_in_series)
|
||||
|
||||
@skip_nested
|
||||
def test_setitem_sequence_mismatched_length_raises(self, data, as_array):
|
||||
# ValueError: PandasArray must be 1-dimensional.
|
||||
super().test_setitem_sequence_mismatched_length_raises(data, as_array)
|
||||
|
||||
@skip_nested
|
||||
def test_setitem_sequence_broadcasts(self, data, box_in_series):
|
||||
# ValueError: cannot set using a list-like indexer with a different
|
||||
# length than the value
|
||||
super().test_setitem_sequence_broadcasts(data, box_in_series)
|
||||
|
||||
@skip_nested
|
||||
def test_setitem_loc_scalar_mixed(self, data):
|
||||
# AssertionError
|
||||
super().test_setitem_loc_scalar_mixed(data)
|
||||
|
||||
@skip_nested
|
||||
def test_setitem_loc_scalar_multiple_homogoneous(self, data):
|
||||
# AssertionError
|
||||
super().test_setitem_loc_scalar_multiple_homogoneous(data)
|
||||
|
||||
@skip_nested
|
||||
def test_setitem_iloc_scalar_mixed(self, data):
|
||||
# AssertionError
|
||||
super().test_setitem_iloc_scalar_mixed(data)
|
||||
|
||||
@skip_nested
|
||||
def test_setitem_iloc_scalar_multiple_homogoneous(self, data):
|
||||
# AssertionError
|
||||
super().test_setitem_iloc_scalar_multiple_homogoneous(data)
|
||||
|
||||
@skip_nested
|
||||
@pytest.mark.parametrize("setter", ["loc", None])
|
||||
def test_setitem_mask_broadcast(self, data, setter):
|
||||
# ValueError: cannot set using a list-like indexer with a different
|
||||
# length than the value
|
||||
super().test_setitem_mask_broadcast(data, setter)
|
||||
|
||||
@skip_nested
|
||||
def test_setitem_scalar_key_sequence_raise(self, data):
|
||||
# Failed: DID NOT RAISE <class 'ValueError'>
|
||||
super().test_setitem_scalar_key_sequence_raise(data)
|
||||
|
||||
|
||||
@skip_nested
|
||||
class TestParsing(BaseNumPyTests, base.BaseParsingTests):
|
||||
pass
|
||||
Reference in New Issue
Block a user