def _generate_scitype_mtype_fixtureindex_combinations():
"""Return fixture tuples for pytest_generate_tests.
Fixtures parameterized
----------------------
scitype : str - scitype of fixture
mtype : str - mtype of fixture
fixture_index : int - index of fixture tuple with that scitype and mtype
"""
# collect fixture tuples here
sci_mtype_tuples = _generate_scitype_mtype_combinations()
sci_mtype_index_tuples = []
for tuple_j in sci_mtype_tuples:
scitype = tuple_j[0]
mtype = tuple_j[1]
n_fixtures = len(get_examples(mtype=mtype, as_scitype=scitype))
for i in range(n_fixtures):
if get_examples(mtype=mtype,
as_scitype=scitype).get(i) is not None:
sci_mtype_index_tuples += [(scitype, mtype, i)]
return sci_mtype_index_tuples
def test_convert(scitype, from_mtype, to_mtype, fixture_index):
"""Tests that conversions for scitype agree with from/to example fixtures.
Parameters
----------
scitype : str - scitypes
from_mtype : str - mtype of "from" conversion to test, belongs to scitype
to_mtype : str - mtype of conversion target ("to") to test, belongs to scitype
from_fixture : int - index of fixture tuple use for conversion
Raises
------
AssertionError if a converted object does not match fixture
error if conversion itself raises an error
"""
# retrieve from/to fixture for conversion
from_fixture = get_examples(mtype=from_mtype,
as_scitype=scitype,
return_lossy=True).get(fixture_index)
to_fixture = get_examples(mtype=to_mtype,
as_scitype=scitype,
return_lossy=True).get(fixture_index)
# retrieve indicators whether conversion makes sense
# to-fixture is in example dict and is not None
cond1 = to_fixture is not None and to_fixture[0] is not None
# from-fixture is in example dict and is not None
cond2 = from_fixture is not None and from_fixture[0] is not None
# from-fixture is not None and not lossy
cond3 = cond2 and from_fixture[1] is not None and not from_fixture[1]
msg = (
f"conversion {from_mtype} to {to_mtype} failed for fixture {fixture_index}, "
"expected result (y) and converted result (x) are not equal because: ")
# test that converted from-fixture equals to-fixture
if cond1 and cond2 and cond3:
converted_fixture_i = convert(
obj=from_fixture[0],
from_type=from_mtype,
to_type=to_mtype,
as_scitype=scitype,
)
equals, deep_equals_msg = deep_equals(
converted_fixture_i,
to_fixture[0],
return_msg=True,
)
assert equals, msg + deep_equals_msg
def test_convert_to_simple():
"""Testing convert_to basic call works."""
scitype = SCITYPES[0]
from_fixt = get_examples(mtype=MTYPES_SERIES[1], as_scitype=scitype).get(0)
# expectation is that the conversion is to mtype MTYPES_SERIES[0]
exp_fixt = get_examples(mtype=MTYPES_SERIES[0], as_scitype=scitype).get(0)
# carry out the conversion using convert_to
converted = convert_to(from_fixt, to_type=MTYPES_SERIES[0], as_scitype=scitype)
# compare expected output with actual output of convert_to
msg = "convert_to basic call does not seem to work."
assert deep_equals(converted, exp_fixt), msg
def test_convert_to_without_scitype():
"""Testing convert_to call without scitype specification."""
scitype = SCITYPES[0]
from_fixt = get_examples(mtype=MTYPES_SERIES[1], as_scitype=scitype).get(0)
# convert_to should recognize the correct scitype, otherwise same as above
exp_fixt = get_examples(mtype=MTYPES_SERIES[0], as_scitype=scitype).get(0)
# carry out the conversion using convert_to
converted = convert_to(from_fixt, to_type=MTYPES_SERIES[0])
# compare expected output with actual output of convert_to
msg = "convert_to call without scitype does not seem to work."
assert deep_equals(converted, exp_fixt), msg
def test_mtype_infer(scitype, mtype, fixture_index):
"""Tests that mtype correctly infers the mtype of examples.
Parameters
----------
scitype : str - name of scitype for which mtype conversions are tested
Raises
------
RuntimeError if scitype is not defined or has no mtypes or examples
AssertionError if mtype of examples is not correctly identified
error if check itself raises an error
"""
# if mtypes are ambiguous, then this test should be skipped
if scitype in SCITYPES_AMBIGUOUS_MTYPE:
return None
# retrieve fixture for checking
fixture = get_examples(mtype=mtype, as_scitype=scitype).get(fixture_index)
# todo: possibly remove this once all checks are defined
check_is_defined = (mtype, scitype) in check_dict.keys()
# check fixtures that exist against checks that exist
if fixture is not None and check_is_defined:
assert mtype == infer_mtype(
fixture, as_scitype=scitype
), f"mtype {mtype} not correctly identified for fixture {fixture_index}"
def test_check_positive(scitype, mtype, fixture_index):
"""Tests that check_is_mtype correctly confirms the mtype of examples.
Parameters
----------
scitype : str - scitype of fixture
mtype : str - mtype of fixture
fixture_index : int - index of fixture tuple with that scitype and mtype
Raises
------
RuntimeError if scitype is not defined or has no mtypes or examples
AssertionError if examples are not correctly identified
error if check itself raises an error
"""
# retrieve fixture for checking
fixture = get_examples(mtype=mtype, as_scitype=scitype).get(fixture_index)
# todo: possibly remove this once all checks are defined
check_is_defined = (mtype, scitype) in check_dict.keys()
# check fixtures that exist against checks that exist
if fixture is not None and check_is_defined:
check_result = check_is_mtype(fixture, mtype, scitype, return_metadata=True)
if not check_result[0]:
msg = (
f"check_is_mtype returns False on scitype {scitype}, mtype {mtype} "
f"fixture {fixture_index}, message: "
)
msg = msg + check_result[1]
assert check_result[0], msg
def test_reconstruct_identical(scitype, mtype, fixture_index, iterate_as):
"""Tests that reconstruct recreates the original input X.
Parameters
----------
scitype : str - name of scitype for which mtype conversions are tested
Raises
------
RuntimeError if scitype is not defined or has no mtypes or examples
AssertionError if examples are not correctly identified
error if check itself raises an error
"""
# escape for the invalid Panel/Panel combination, see above
if iterate_as == "Panel" and scitype == "Panel":
return None
# retrieve fixture for checking
fixture = get_examples(mtype=mtype, as_scitype=scitype).get(fixture_index)
# construct VectorizedDF - we've tested above that this works
X_vect = VectorizedDF(X=fixture, iterate_as=iterate_as, is_scitype=None)
# get list of iterated elements - we've tested above that this yields correct result
X_list = list(X_vect)
# reconstructed fixture should equal multiindex fixture if not convert_back
assert deep_equals(X_vect.reconstruct(X_list), X_vect.X_multiindex)
# reconstructed fixture should equal original fixture if convert_back
assert deep_equals(X_vect.reconstruct(X_list, convert_back=True), fixture)
def test_scitype_infer(scitype, mtype, fixture_index):
"""Tests that scitype correctly infers the mtype of examples.
Parameters
----------
scitype : str - scitype of fixture
mtype : str - mtype of fixture
fixture_index : int - index of fixture tuple with that scitype and mtype
Raises
------
RuntimeError if scitype is not defined or has no mtypes or examples
AssertionError if mtype of examples is not correctly identified
error if check itself raises an error
"""
# if mtypes are ambiguous, then this test should be skipped
if scitype in SKIP_SCITYPES or mtype in AMBIGUOUS_MTYPES:
return None
# retrieve fixture for checking
fixture = get_examples(mtype=mtype, as_scitype=scitype).get(fixture_index)
# todo: possibly remove this once all checks are defined
check_is_defined = (mtype, scitype) in check_dict.keys()
# check fixtures that exist against checks that exist
if fixture is not None and check_is_defined:
assert scitype == infer_scitype(
fixture, candidate_scitypes=SCITYPES_FOR_INFER_TEST
), f"mtype {mtype} not correctly identified for fixture {fixture_index}"
def test_iteration(scitype, mtype, fixture_index, iterate_as):
"""Tests __getitem__ returns pd-multiindex mtype if iterate_as="Series".
Fixtures parameterized
----------------------
scitype : str - scitype of fixture
mtype : str - mtype of fixture
fixture_index : int - index of fixture tuple with that scitype and mtype
iterate_as : str - level on which to iterate over
"""
# escape for the invalid Panel/Panel combination, see above
if iterate_as == "Panel" and scitype == "Panel":
return None
# retrieve fixture for checking
fixture = get_examples(mtype=mtype, as_scitype=scitype).get(fixture_index)
# construct VectorizedDF - we've tested above that this works
X_vect = VectorizedDF(X=fixture, iterate_as=iterate_as, is_scitype=None)
# testing list comprehension works with indexing
X_iter1 = [X_vect[i] for i in range(len(X_vect))]
assert isinstance(X_iter1, list)
# testing that iterator comprehension works
X_iter2 = [X_idx for X_idx in X_vect]
assert isinstance(X_iter2, list)
# testing that as_list method works
X_iter3 = X_vect.as_list()
assert isinstance(X_iter3, list)
# check that these are all the same
assert deep_equals(X_iter1, X_iter2)
assert deep_equals(X_iter2, X_iter3)
def test_get_window_output_type(scitype, mtype, window_length, lag):
"""Tests that get_window runs for all mtypes, and returns output of same mtype.
Parameters
----------
scitype : str - scitype of input
mtype : str - mtype of input
window_length : int, passed to get_window
lag : int, passed to get_window
Raises
------
Exception if get_window raises one
"""
# retrieve example fixture
fixture = get_examples(mtype=mtype, as_scitype=scitype,
return_lossy=False)[0]
X = get_window(fixture, window_length=window_length, lag=lag)
valid, err, _ = check_is_mtype(X, mtype=mtype, return_metadata=True)
msg = (
f"get_window should return an output of mtype {mtype} for that type of input, "
f"but it returns an output not conformant with that mtype."
f"Error from mtype check: {err}")
assert valid, msg
def _generate_fixture_tuples():
"""Return fixture tuples for pytest_generate_tests."""
# collect fixture tuples here
fixture_tuples = []
for scitype in SCITYPES:
# if we know there are no conversions defined, skip this scitype
if scitype in SCITYPES_NO_CONVERSIONS:
continue
conv_mat = _conversions_defined(scitype)
mtypes = conv_mat.index.values
if len(mtypes) == 0:
# if there are no mtypes, this must have been reached by mistake/bug
raise RuntimeError("no mtypes defined for scitype " + scitype)
# by convention, number of examples is the same for all mtypes of the scitype
examples = get_examples(mtype=mtypes[0], as_scitype=scitype, return_lossy=True)
n_fixtures = len(examples)
# there must be fixtures for each scitype, otherwise there is a bug in the tests
if n_fixtures == 0:
raise RuntimeError("no fixtures defined for scitype " + scitype)
for to_type in mtypes:
for from_type in mtypes:
for i in range(n_fixtures):
# only add if conversion is implemented
if conv_mat[to_type][from_type]:
fixture_tuples += [(scitype, from_type, to_type, i)]
return fixture_tuples
def test_check_positive(scitype):
"""Tests that check_is_mtype correctly confirms the mtype of examples.
Parameters
----------
scitype : str - name of scitype for which mtype conversions are tested
Raises
------
RuntimeError if scitype is not defined or has no mtypes or examples
AssertionError if examples are not correctly identified
error if check itself raises an error
"""
if scitype not in [s[0] for s in SCITYPE_REGISTER]:
raise RuntimeError(scitype + " is not in the SCITYPE_REGISTER")
mtypes = [key[0] for key in MTYPE_REGISTER if key[1] == scitype]
if len(mtypes) == 0:
raise RuntimeError("no mtypes defined for scitype " + scitype)
fixtures = dict()
for mtype in mtypes:
# if we don't do this we get into a clash between linters
mtype_long_variable_name_to_avoid_linter_clash = mtype
fixtures[mtype] = get_examples(
mtype=mtype_long_variable_name_to_avoid_linter_clash,
as_scitype=scitype,
)
n_fixtures = np.max([len(fixtures[mtype]) for mtype in mtypes])
if n_fixtures == 0:
raise RuntimeError("no fixtures defined for scitype " + scitype)
for i in range(n_fixtures):
for mtype in mtypes:
# retrieve fixture for checking
fixture = fixtures[mtype].get(i)
# todo: possibly remove this once all checks are defined
check_is_defined = (mtype, scitype) in check_dict.keys()
# check fixtures that exist against checks that exist
if fixture is not None and check_is_defined:
check_result = check_is_mtype(
fixture, mtype, scitype, return_metadata=True
)
if not check_result[0]:
msg = (
f"check_is_mtype returns False on {mtype} "
f"fixture {i}, message: "
)
msg = msg + check_result[1]
assert check_result[0], msg
def test_check_negative(scitype):
"""Tests that check_is_mtype correctly identifies wrong mtypes of examples.
Parameters
----------
scitype : str - name of scitype for which mtype conversions are tested
Raises
------
RuntimeError if scitype is not defined or has no mtypes or examples
AssertionError if a examples are correctly identified as incompatible
error if check itself raises an error
"""
if scitype not in [s[0] for s in SCITYPE_REGISTER]:
raise RuntimeError(scitype + " is not in the SCITYPE_REGISTER")
if scitype in SCITYPES_AMBIGUOUS_MTYPE:
return None
mtypes = [key[0] for key in MTYPE_REGISTER if key[1] == scitype]
if len(mtypes) == 0:
raise RuntimeError("no mtypes defined for scitype " + scitype)
fixtures = dict()
for mtype in mtypes:
# if we don't do this we get into a clash between linters
mtype_long_variable_name_to_avoid_linter_clash = mtype
fixtures[mtype] = get_examples(
mtype=mtype_long_variable_name_to_avoid_linter_clash,
as_scitype=scitype,
)
n_fixtures = np.max([len(fixtures[mtype]) for mtype in mtypes])
if n_fixtures == 0:
raise RuntimeError("no fixtures defined for scitype " + scitype)
for i in range(n_fixtures):
for mtype in mtypes:
for wrong_mtype in list(set(mtypes).difference(set([mtype]))):
# retrieve fixture for checking
fixture_wrong_type = fixtures[wrong_mtype].get(i)
# todo: possibly remove this once all checks are defined
check_is_defined = (mtype, scitype) in check_dict.keys()
# check fixtures that exist against checks that exist
if fixture_wrong_type is not None and check_is_defined:
assert not check_is_mtype(fixture_wrong_type, mtype, scitype), (
f"check_is_mtype {mtype} returns True "
f"on {wrong_mtype} fixture {i}"
)
def test_convert_to_mtype_list():
"""Testing convert_to call to_type being a list, of same scitype."""
# convert_to list
target_list = MTYPES_SERIES[:2]
scitype = SCITYPES[0]
# example that is on the list
from_fixt_on = get_examples(mtype=MTYPES_SERIES[1], as_scitype=scitype).get(0)
# example that is not on the list
from_fixt_off = get_examples(mtype=MTYPES_SERIES[2], as_scitype=scitype).get(0)
# if on the list, result should be equal to input
exp_fixt_on = get_examples(mtype=MTYPES_SERIES[1], as_scitype=scitype).get(0)
# if off the list, result should be converted to mtype that is first on the list
exp_fixt_off = get_examples(mtype=MTYPES_SERIES[0], as_scitype=scitype).get(0)
# carry out the conversion using convert_to
converted_on = convert_to(from_fixt_on, to_type=target_list)
converted_off = convert_to(from_fixt_off, to_type=target_list)
# compare expected output with actual output of convert_to
msg = "convert_to call does not work with list for to_type."
assert deep_equals(converted_on, exp_fixt_on), msg
assert deep_equals(converted_off, exp_fixt_off), msg
def test_get_window_expected_result():
"""Tests that get_window produces return of the right length.
Raises
------
Exception if get_window raises one
"""
X_df = get_examples(mtype="pd.DataFrame")[0]
assert len(get_window(X_df, 2, 1)) == 2
assert len(get_window(X_df, 3, 1)) == 3
assert len(get_window(X_df, 1, 2)) == 1
assert len(get_window(X_df, 3, 4)) == 0
X_mi = get_examples(mtype="pd-multiindex")[0]
assert len(get_window(X_mi, 3, 1)) == 6
assert len(get_window(X_mi, 2, 0)) == 6
assert len(get_window(X_mi, 2, 4)) == 0
assert len(get_window(X_mi, 1, 2)) == 3
X_hi = get_examples(mtype="pd_multiindex_hier")[0]
assert len(get_window(X_hi, 3, 1)) == 12
assert len(get_window(X_hi, 2, 0)) == 12
assert len(get_window(X_hi, 2, 4)) == 0
assert len(get_window(X_hi, 1, 2)) == 6
def test_check_negative(scitype, mtype):
"""Tests that check_is_mtype correctly identifies wrong mtypes of examples.
Parameters
----------
scitype : str - scitype of fixture
mtype : str - mtype of fixture
Raises
------
RuntimeError if scitype is not defined or has no mtypes or examples
AssertionError if a examples are correctly identified as incompatible
error if check itself raises an error
"""
# if the scitype is ambiguous, we can't assume that other mtypes are negative
if scitype in SCITYPES_AMBIGUOUS_MTYPE:
return None
mtypes = scitype_to_mtype(scitype)
fixtures = dict()
for other_mtype in mtypes:
fixtures[other_mtype] = get_examples(mtype=other_mtype, as_scitype=scitype)
n_fixtures = np.max([len(fixtures[mtype]) for mtype in mtypes])
if n_fixtures == 0:
raise RuntimeError("no fixtures defined for scitype " + scitype)
for i in range(n_fixtures):
# if mtype is not ambiguous, other mtypes are negative examples
for wrong_mtype in list(set(mtypes).difference(set([mtype]))):
# retrieve fixture for checking
fixture_wrong_type = fixtures[wrong_mtype].get(i)
# todo: possibly remove this once all checks are defined
check_is_defined = (mtype, scitype) in check_dict.keys()
# check fixtures that exist against checks that exist
if fixture_wrong_type is not None and check_is_defined:
assert not check_is_mtype(fixture_wrong_type, mtype, scitype), (
f"check_is_mtype {mtype} returns True "
f"on {wrong_mtype} fixture {i}"
)
def test_check_metadata_inference(scitype, mtype, fixture_index):
"""Tests that check_is_mtype correctly infers metadata of examples.
Parameters
----------
scitype : str - scitype of fixture
mtype : str - mtype of fixture
fixture_index : int - index of fixture tuple with that scitype and mtype
Raises
------
RuntimeError if scitype is not defined or has no mtypes or examples
AssertionError if example metadata is not correctly inferred
error if check itself raises an error
"""
# retrieve fixture for checking
fixture, _, expected_metadata = get_examples(
mtype=mtype, as_scitype=scitype, return_metadata=True
).get(fixture_index)
# todo: possibly remove this once all checks are defined
check_is_defined = (mtype, scitype) in check_dict.keys()
# if the examples have no metadata to them, don't test
metadata_provided = expected_metadata is not None
# check fixtures that exist against checks that exist
if fixture is not None and check_is_defined and metadata_provided:
check_result = check_is_mtype(fixture, mtype, scitype, return_metadata=True)
metadata = check_result[2]
# remove mtype & scitype key if exists, since comparison is on scitype level
if "mtype" in metadata:
del metadata["mtype"]
if "scitype" in metadata:
del metadata["scitype"]
msg = (
f"check_is_mtype returns wrong metadata on scitype {scitype}, "
f"mtype {mtype}, fixture {fixture_index}. "
f"returned: {metadata}; expected: {expected_metadata}"
)
assert metadata == expected_metadata, msg
def test_construct_vectorizeddf(scitype, mtype, fixture_index):
"""Test VectorizedDF constructs with valid arguments.
Fixtures parameterized
----------------------
scitype : str - scitype of fixture
mtype : str - mtype of fixture
fixture_index : int - index of fixture tuple with that scitype and mtype
"""
# retrieve fixture for checking
fixture = get_examples(mtype=mtype, as_scitype=scitype).get(fixture_index)
# iterate as Series, without automated identification of scitype
VectorizedDF(X=fixture, iterate_as="Series", is_scitype=scitype)
# iterate as Series, with automated identification of scitype
VectorizedDF(X=fixture, iterate_as="Series", is_scitype=None)
# iterate as Panel, can only do this if scitype is hierarchical
if scitype == "Hierarchical":
VectorizedDF(X=fixture, iterate_as="Panel", is_scitype=None)
def test_item_len(scitype, mtype, fixture_index, iterate_as):
"""Tests __len__ returns correct length.
Fixtures parameterized
----------------------
scitype : str - scitype of fixture
mtype : str - mtype of fixture
fixture_index : int - index of fixture tuple with that scitype and mtype
iterate_as : str - level on which to iterate over
"""
# escape for the invalid Panel/Panel combination, see above
if iterate_as == "Panel" and scitype == "Panel":
return None
# retrieve fixture for checking
fixture = get_examples(mtype=mtype, as_scitype=scitype).get(fixture_index)
# get true length
if iterate_as == "Series":
_, _, metadata = check_is_mtype(fixture,
mtype=mtype,
scitype=scitype,
return_metadata=True)
true_length = metadata["n_instances"]
elif iterate_as == "Panel":
_, _, metadata = check_is_mtype(fixture,
mtype=mtype,
scitype=scitype,
return_metadata=True)
true_length = metadata["n_panels"]
# construct VectorizedDF - we've tested above that this works
X_vect = VectorizedDF(X=fixture, iterate_as=iterate_as, is_scitype=None)
# check length against n_instances metadata field
assert len(X_vect) == true_length, (
"X_vect.__len__ returns incorrect length.",
f"True={true_length}, returned={len(X_vect)}",
)
def test_series_item_mtype(scitype, mtype, fixture_index, iterate_as):
"""Tests __getitem__ returns correct pd-multiindex mtype.
Fixtures parameterized
----------------------
scitype : str - scitype of fixture
mtype : str - mtype of fixture
fixture_index : int - index of fixture tuple with that scitype and mtype
iterate_as : str - level on which to iterate over
"""
# escape for the invalid Panel/Panel combination, see above
if iterate_as == "Panel" and scitype == "Panel":
return None
# retrieve fixture for checking
fixture = get_examples(mtype=mtype, as_scitype=scitype).get(fixture_index)
# construct VectorizedDF - we've tested above that this works
X_vect = VectorizedDF(X=fixture, iterate_as=iterate_as, is_scitype=None)
# get list of iterated elements - we've tested above that this works
X_list = list(X_vect)
# right mtype depends on scitype
if iterate_as == "Series":
correct_mtype = "pd.DataFrame"
elif iterate_as == "Panel":
correct_mtype = "pd-multiindex"
else:
RuntimeError(f"found unexpected iterate_as value: {iterate_as}")
X_list_valid = [
check_is_mtype(X, mtype=correct_mtype, scitype=iterate_as)
for X in X_list
]
assert np.all(
X_list_valid
), f"iteration elements do not conform with expected mtype {correct_mtype}"
def test_convert_to_mtype_list_different_scitype():
"""Testing convert_to call to_type being a list, of different scitypes."""
# convert_to list
target_list = MTYPES_SERIES[:2] + MTYPES_PANEL[:2]
scitype0 = SCITYPES[0]
scitype1 = SCITYPES[1]
# example that is on the list and of scitype0
from_fixt_on_0 = get_examples(mtype=MTYPES_SERIES[1], as_scitype=scitype0).get(0)
# example that is not on the list and of scitype0
from_fixt_off_0 = get_examples(mtype=MTYPES_SERIES[2], as_scitype=scitype0).get(0)
# example that is on the list and of scitype1
from_fixt_on_1 = get_examples(mtype=MTYPES_PANEL[1], as_scitype=scitype1).get(0)
# example that is not on the list and of scitype1
from_fixt_off_1 = get_examples(mtype=MTYPES_PANEL[2], as_scitype=scitype1).get(0)
# if on the list, result should be equal to input
exp_fixt_on_0 = get_examples(mtype=MTYPES_SERIES[1], as_scitype=scitype0).get(0)
exp_fixt_on_1 = get_examples(mtype=MTYPES_PANEL[1], as_scitype=scitype1).get(0)
# if off the list, result should be converted to mtype
# of the same scitype that appears earliest on the list
exp_fixt_off_0 = get_examples(mtype=MTYPES_SERIES[0], as_scitype=scitype0).get(0)
exp_fixt_off_1 = get_examples(mtype=MTYPES_PANEL[0], as_scitype=scitype1).get(0)
# carry out the conversion using convert_to
converted_on_0 = convert_to(from_fixt_on_0, to_type=target_list)
converted_off_0 = convert_to(from_fixt_off_0, to_type=target_list)
converted_on_1 = convert_to(from_fixt_on_1, to_type=target_list)
converted_off_1 = convert_to(from_fixt_off_1, to_type=target_list)
# compare expected output with actual output of convert_to
msg = "convert_to call does not work with list for to_type of different scitypes."
assert deep_equals(converted_on_0, exp_fixt_on_0), msg
assert deep_equals(converted_off_0, exp_fixt_off_0), msg
assert deep_equals(converted_on_1, exp_fixt_on_1), msg
assert deep_equals(converted_off_1, exp_fixt_off_1), msg
def test_construct_vectorizeddf_errors(scitype, mtype, fixture_index):
"""Test VectorizedDF raises appropriate errors with invalid arguments.
Fixtures parameterized
----------------------
scitype : str - scitype of fixture
mtype : str - mtype of fixture
fixture_index : int - index of fixture tuple with that scitype and mtype
"""
# retrieve fixture for checking
fixture = get_examples(mtype=mtype, as_scitype=scitype).get(fixture_index)
# if both iterate_as and as_scitype are "Panel", should raise an error
with pytest.raises(ValueError, match=r'is_scitype is "Panel"'):
VectorizedDF(X=fixture, iterate_as="Panel", is_scitype="Panel")
# invalid argument to iterate_as
with pytest.raises(ValueError, match=r"iterate_as must be"):
VectorizedDF(X=fixture, iterate_as="Pumuckl", is_scitype="Panel")
# invalid argument to is_scitype
with pytest.raises(ValueError, match=r"is_scitype must be"):
VectorizedDF(X=fixture, iterate_as="Panel", is_scitype="Pumuckl")
def test_get_cutoff(scitype, mtype, return_index):
"""Tests that conversions for scitype agree with from/to example fixtures.
Parameters
----------
scitype : str - scitype of input
mtype : str - mtype of input
return_index : bool - whether index (True) or index element is returned (False)
Raises
------
AssertionError if get_cutoff does not return a length 1 pandas.index
for any fixture example of given scitype, mtype
"""
# retrieve example fixture
fixtures = get_examples(mtype=mtype,
as_scitype=scitype,
return_lossy=False)
for fixture in fixtures.values():
if fixture is None:
continue
cutoff = get_cutoff(fixture, return_index=return_index)
if return_index:
expected_types = pd.Index
else:
expected_types = (int, float, np.int64, pd.Timestamp)
msg = (f"incorrect return type of get_cutoff"
f"expected {expected_types}, found {type(cutoff)}")
assert isinstance(cutoff, expected_types), msg
if return_index:
assert len(cutoff) == 1
def test_convert(scitype):
"""Tests that conversions for scitype agree with from/to example fixtures.
Parameters
----------
scitype : str - name of scitype for which mtype conversions are tested
Raises
------
AssertionError if a converted object does not match fixture
error if conversion itself raises an error
"""
conv_mat = _conversions_defined(scitype)
mtypes = conv_mat.index.values
if len(mtypes) == 0:
raise RuntimeError("no mtypes defined for scitype " + scitype)
fixtures = dict()
for mtype in mtypes:
# if we don't do this we get into a clash between linters
mtype_long_variable_name_to_avoid_linter_clash = mtype
fixtures[mtype] = get_examples(
mtype=mtype_long_variable_name_to_avoid_linter_clash,
as_scitype=scitype,
return_lossy=True,
)
if len(fixtures[mtypes[0]]) == 0:
raise RuntimeError("no fixtures defined for scitype " + scitype)
# by convention, all fixtures are mirrored across all mtypes
# so len(fixtures[mtypes[i]]) does not depend on i
n_fixtures = len(fixtures[mtypes[0]])
for i in range(n_fixtures):
for from_type in mtypes:
for to_type in mtypes:
# retrieve from/to fixture for conversion
to_fixture = fixtures[to_type].get(i)
from_fixture = fixtures[from_type].get(i)
# retrieve indicators whether conversion makes sense
# to-fixture is in example dict and is not None
cond1 = to_fixture is not None and to_fixture[0] is not None
# from-fixture is in example dict and is not None
cond2 = from_fixture is not None and from_fixture[0] is not None
# from-fixture is not None and not lossy
cond3 = cond2 and from_fixture[
1] is not None and not from_fixture[1]
# conversion is implemented
cond4 = conv_mat[to_type][from_type]
msg = f"conversion {from_type} to {to_type} failed for fixture {i}"
# test that converted from-fixture equals to-fixture
if cond1 and cond2 and cond3 and cond4:
converted_fixture_i = convert(
obj=from_fixture[0],
from_type=from_type,
to_type=to_type,
as_scitype=scitype,
)
assert deep_equals(
converted_fixture_i,
to_fixture[0],
), msg
