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