def test_weight_column_not_in_X_error(self): """Test that an exception is raised if weight is not in X.""" df = d.create_df_5() x = GroupRareLevelsTransformer(columns=["a", "b", "c"], weight="aaaa") with pytest.raises(ValueError, match="weight aaaa not in X"): x.fit(df)
def test_fit_returns_self(self): """Test fit returns self?""" df = d.create_df_5() x = GroupRareLevelsTransformer(columns=["a", "b", "c"]) x_fitted = x.fit(df) assert ( x_fitted is x ), "Returned value from GroupRareLevelsTransformer.fit not as expected."
def test_fit_not_changing_data(self): """Test fit does not change X.""" df = d.create_df_5() x = GroupRareLevelsTransformer(columns=["a", "b", "c"]) x.fit(df) h.assert_equal_dispatch( expected=d.create_df_5(), actual=df, msg="Check X not changing during fit", )
def test_expected_output_no_weight(self, df, expected): """Test that the output is expected from transform.""" x = GroupRareLevelsTransformer(columns=["b", "c"], cut_off_percent=0.2) # set the mappging dict directly rather than fitting x on df so test works with decorators x.mapping_ = {"b": ["a", np.NaN], "c": ["e", "c", "a"]} df_transformed = x.transform(df) h.assert_frame_equal_msg( actual=df_transformed, expected=expected, msg_tag="Unexpected values in GroupRareLevelsTransformer.transform", )
def test_cut_off_percent_negative_error(self): """Test that an exception is raised if cut_off_percent is negative.""" with pytest.raises(ValueError, match="cut_off_percent must be > 0 and < 1"): GroupRareLevelsTransformer(cut_off_percent=-1.0)
def test_record_rare_levels_not_str_error(self): """Test that an exception is raised if record_rare_levels is not a bool.""" with pytest.raises(ValueError, match="record_rare_levels must be a bool"): GroupRareLevelsTransformer(record_rare_levels=2)
def test_cut_off_percent_gt_one_error(self): """Test that an exception is raised if cut_off_percent is greater than 1.""" with pytest.raises(ValueError, match="cut_off_percent must be > 0 and < 1"): GroupRareLevelsTransformer(cut_off_percent=2.0)
def test_cut_off_percent_not_float_error(self): """Test that an exception is raised if cut_off_percent is not an float.""" with pytest.raises(ValueError, match="cut_off_percent must be a float"): GroupRareLevelsTransformer(cut_off_percent="a")
def test_weight_not_str_error(self): """Test that an exception is raised if weight is not a str, if supplied.""" with pytest.raises(ValueError, match="weight should be a single column"): GroupRareLevelsTransformer(weight=2)
def test_expected_output_no_weight_single_row_na(self): """test output from a single row transform with np.NaN value remains the same, the type is perserved if using existing dataframe, so need to create a new dataframe""" one_row_df = pd.DataFrame({"b": [np.nan], "c": [np.NaN]}) x = GroupRareLevelsTransformer(columns=["b", "c"], cut_off_percent=0.2) # set the mappging dict directly rather than fitting x on df so test works with decorators x.mapping_ = {"b": ["a", np.NaN], "c": ["e", "c", "a", np.NaN]} one_row_df_transformed = x.transform(one_row_df) h.assert_frame_equal_msg( actual=one_row_df_transformed, expected=one_row_df, msg_tag="Unexpected values in GroupRareLevelsTransformer.transform", )
def test_super_fit_called(self, mocker): """Test that fit calls BaseTransformer.fit.""" df = d.create_df_5() x = GroupRareLevelsTransformer(columns=["a", "b", "c"]) expected_call_args = { 0: { "args": (d.create_df_5(), None), "kwargs": {} } } with h.assert_function_call(mocker, tubular.base.BaseTransformer, "fit", expected_call_args): x.fit(df)
def test_learnt_values_weight_2(self): """Test that the impute values learnt during fit, using a weight, are expected.""" df = d.create_df_6() x = GroupRareLevelsTransformer(columns=["c"], cut_off_percent=0.2, weights="a") x.fit(df) h.test_object_attributes( obj=x, expected_attributes={"mapping_": { "c": ["f", "g"] }}, msg="mapping_ attribute", )
def test_class_methods(self): """Test that GroupRareLevelsTransformer has fit and transform methods.""" x = GroupRareLevelsTransformer() h.test_object_method(obj=x, expected_method="fit", msg="fit") h.test_object_method(obj=x, expected_method="transform", msg="transform")
def test_learnt_values_no_weight(self): """Test that the impute values learnt during fit, without using a weight, are expected.""" df = d.create_df_5() x = GroupRareLevelsTransformer(columns=["b", "c"], cut_off_percent=0.2) x.fit(df) h.test_object_attributes( obj=x, expected_attributes={ "mapping_": { "b": ["a", np.NaN], "c": ["a", "c", "e"] } }, msg="mapping_ attribute", )
def test_learnt_values_not_modified(self): """Test that the mapping_ from fit are not changed in transform.""" df = d.create_df_5() x = GroupRareLevelsTransformer(columns=["a", "b", "c"]) x.fit(df) x2 = GroupRareLevelsTransformer(columns=["a", "b", "c"]) x2.fit(df) x2.transform(df) h.assert_equal_dispatch( expected=x.mapping_, actual=x2.mapping_, msg="Non rare levels not changed in transform", )
def test_super_init_called(self, mocker): """Test that init calls BaseTransformer.init.""" expected_call_args = { 0: { "args": (), "kwargs": { "columns": None, "verbose": True, "copy": True } } } with h.assert_function_call(mocker, tubular.base.BaseTransformer, "__init__", expected_call_args): GroupRareLevelsTransformer(columns=None, verbose=True, copy=True)
def test_values_passed_in_init_set_to_attribute(self): """Test that the values passed in init are saved in an attribute of the same name.""" x = GroupRareLevelsTransformer( cut_off_percent=0.05, weight="aaa", rare_level_name="bbb", record_rare_levels=False, ) h.test_object_attributes( obj=x, expected_attributes={ "cut_off_percent": 0.05, "weight": "aaa", "rare_level_name": "bbb", "record_rare_levels": False, }, msg="Attributes for GroupRareLevelsTransformer set in init", )
def test_check_is_fitted_called(self, mocker): """Test that BaseTransformer check_is_fitted called.""" df = d.create_df_5() x = GroupRareLevelsTransformer(columns=["a", "b", "c"]) x.fit(df) expected_call_args = {0: {"args": (["mapping_"], ), "kwargs": {}}} with h.assert_function_call(mocker, tubular.base.BaseTransformer, "check_is_fitted", expected_call_args): x.transform(df)
def test_super_transform_called(self, mocker): """Test that BaseTransformer.transform called.""" df = d.create_df_5() x = GroupRareLevelsTransformer(columns=["a", "b", "c"]) x.fit(df) expected_call_args = {0: {"args": (d.create_df_5(), ), "kwargs": {}}} with h.assert_function_call( mocker, tubular.base.BaseTransformer, "transform", expected_call_args, return_value=d.create_df_5(), ): x.transform(df)
def test_rare_level_name_not_str_error(self): """Test that an exception is raised if rare_level_name is not a str.""" with pytest.raises(ValueError, match="rare_level_name must be a str"): GroupRareLevelsTransformer(rare_level_name=2)
def test_inheritance(self): """Test that NominalToIntegerTransformer inherits from BaseNominalTransformer.""" x = GroupRareLevelsTransformer() h.assert_inheritance(x, tubular.nominal.BaseNominalTransformer)