def test_super_transform_called(self, mocker):
"""Test that BaseMappingTransformMixin.transform called."""
df = d.create_OrdinalEncoderTransformer_test_df()
x = OrdinalEncoderTransformer(response_column="a", columns="b")
x.fit(df)
expected_call_args = {
0: {
"args": (
x,
d.create_OrdinalEncoderTransformer_test_df(),
),
"kwargs": {},
}
}
with h.assert_function_call(
mocker,
tubular.mapping.BaseMappingTransformMixin,
"transform",
expected_call_args,
return_value=d.create_OrdinalEncoderTransformer_test_df(),
):
x.transform(df)
def test_super_init_called(self, mocker):
"""Test that init calls BaseTransformer.init."""
expected_call_args = {
0: {
"args": (),
"kwargs": {
"columns": ["a", "b"],
"verbose": True,
"copy": True
},
}
}
with h.assert_function_call(mocker, tubular.base.BaseTransformer,
"__init__", expected_call_args):
LogTransformer(
columns=["a", "b"],
add_1=True,
drop=True,
suffix="_new",
verbose=True,
copy=True,
)
def test_prepare_quantiles_call_weight(self, mocker):
"""Test the call to prepare_quantiles if weights_column is set."""
df = d.create_df_9()
x = CappingTransformer(
quantiles={"a": [0.1, 1], "b": [0.5, None]}, weights_column="c"
)
expected_call_args = {
0: {
"args": (d.create_df_9()["a"], [0.1, 1], d.create_df_9()["c"]),
"kwargs": {},
},
1: {
"args": (d.create_df_9()["b"], [0.5, None], d.create_df_9()["c"]),
"kwargs": {},
},
}
with h.assert_function_call(
mocker,
tubular.capping.CappingTransformer,
"prepare_quantiles",
expected_call_args,
):
x.fit(df)
def test_pd_cut_call(self, mocker):
"""Test the call to pd.cut is as expected."""
df = d.create_df_9()
x = CutTransformer(
column="a",
new_column_name="a_cut",
cut_kwargs={
"bins": 3,
"right": False,
"precision": 2
},
)
expected_call_args = {
0: {
"args": (d.create_df_9()["a"], ),
"kwargs": {
"bins": 3,
"right": False,
"precision": 2
},
}
}
with h.assert_function_call(mocker,
pandas,
"cut",
expected_call_args,
return_value=[1, 2, 3, 4, 5, 6]):
x.transform(df)
def test_super_transform_call(self, mocker):
"""Test the call to BaseTransformer.transform."""
df = d.create_df_1()
mapping = {
"a": {
1: "a",
2: "b",
3: "c",
4: "d",
5: "e",
6: "f"
},
"b": {
"a": 1,
"b": 2,
"c": 3,
"d": 4,
"e": 5,
"f": 6
},
}
x = BaseMappingTransformer(mappings=mapping)
expected_call_args = {0: {"args": (d.create_df_1(), ), "kwargs": {}}}
with h.assert_function_call(mocker, tubular.base.BaseTransformer,
"transform", expected_call_args):
x.transform(df)
def test_super_init_called(self, mocker):
"""Test that super.__init__ called."""
expected_call_args = {
0: {
"args": (),
"kwargs": {
"columns": ["a", "b", "c"],
"verbose": False,
"copy": True,
},
}
}
with h.assert_function_call(mocker, tubular.base.BaseTransformer,
"__init__", expected_call_args):
BetweenDatesTransformer(
column_lower="a",
column_between="b",
column_upper="c",
new_column_name="d",
verbose=False,
copy=True,
)
def test_not_enough_function_calls_exception(mocker):
"""Test an exception is raised if the mocked function is not called enough time for the number of expected_call_arguments items."""
expected_call_arguments = {
2: {
"args": (["a", "b"], ),
"kwargs": {}
},
5: {
"args": (),
"kwargs": {
"columns": ["a", "b"]
}
},
}
with pytest.raises(
AssertionError,
match="not enough calls to __init__, expected at least 6 but got 4",
):
with h.assert_function_call(
mocker,
tubular.base.BaseTransformer,
"__init__",
expected_call_arguments,
return_value=None,
):
tubular.imputers.BaseImputer("a", other=1)
tubular.imputers.ArbitraryImputer(1, columns=["a"])
tubular.base.BaseTransformer(["a", "b"])
tubular.imputers.BaseImputer(columns=["a", "b"])
def test_successful_function_call(mocker):
"""Test a successful function call with the correct arguments specified."""
expected_call_arguments = {
0: {
"args": ("a", ),
"kwargs": {
"other": 1
}
},
2: {
"args": (["a", "b"], ),
"kwargs": {}
},
3: {
"args": (),
"kwargs": {
"columns": ["a", "b"]
}
},
}
with h.assert_function_call(
mocker,
tubular.base.BaseTransformer,
"__init__",
expected_call_arguments,
return_value=None,
):
tubular.imputers.BaseImputer("a", other=1)
tubular.imputers.ArbitraryImputer(1, columns=["a"])
tubular.imputers.BaseTransformer(["a", "b"])
tubular.imputers.BaseImputer(columns=["a", "b"])
def test_super_init_called(self, mocker):
"""Test that init calls BaseMappingTransformer.init."""
expected_call_args = {
0: {
"args": (),
"kwargs": {
"mappings": {
"a": {
"a": 1
}
},
"verbose": True,
"copy": True,
},
}
}
with h.assert_function_call(
mocker,
tubular.mapping.BaseMappingTransformer,
"__init__",
expected_call_args,
):
CrossColumnAddTransformer(mappings={"a": {
"a": 1
}},
adjust_column="b",
verbose=True,
copy=True)
def test_to_datetime_call(self, mocker):
"""Test the call to pd.to_datetime is as expected."""
df = d.create_to_datetime_test_df()
to_dt = ToDatetimeTransformer(column="a",
new_column_name="a_Y",
to_datetime_kwargs={"format": "%Y"})
expected_call_args = {
0: {
"args": (d.create_to_datetime_test_df()["a"], ),
"kwargs": {
"format": "%Y"
},
}
}
with h.assert_function_call(
mocker,
pandas,
"to_datetime",
expected_call_args,
return_value=pd.to_datetime(
d.create_to_datetime_test_df()["a"]),
):
to_dt.transform(df)
def test_super_transform_called(self, mocker):
"""Test that BaseTransformer.transform called."""
df = d.create_datediff_test_df()
x = DateDifferenceTransformer(
column_lower="a",
column_upper="b",
new_column_name="Y",
units="Y",
copy=True,
verbose=False,
)
expected_call_args = {
0: {
"args": (d.create_datediff_test_df(), ),
"kwargs": {}
}
}
with h.assert_function_call(
mocker,
tubular.base.BaseTransformer,
"transform",
expected_call_args,
return_value=d.create_datediff_test_df(),
):
x.transform(df)
def test_super_transform_call(self, mocker):
"""Test the call to BaseMappingTransformer.transform."""
df = d.create_df_1()
mapping = {
"b": {
"a": 1.1,
"b": 1.2,
"c": 1.3,
"d": 1.4,
"e": 1.5,
"f": 1.6
}
}
x = CrossColumnAddTransformer(mappings=mapping, adjust_column="a")
expected_call_args = {0: {"args": (d.create_df_1(), ), "kwargs": {}}}
with h.assert_function_call(
mocker,
tubular.base.BaseTransformer,
"transform",
expected_call_args,
return_value=d.create_df_1(),
):
x.transform(df)
def test_check_is_fitted_call(self, mocker):
"""Test the call to check_is_fitted."""
df = d.create_df_1()
mapping = {
"a": {
1: "a",
2: "b",
3: "c",
4: "d",
5: "e",
6: "f"
},
"b": {
"a": 1,
"b": 2,
"c": 3,
"d": 4,
"e": 5,
"f": 6
},
}
x = BaseMappingTransformMixin()
x.columns = ["a", "b"]
x.mappings = mapping
expected_call_args = {0: {"args": (["mappings"], ), "kwargs": {}}}
with h.assert_function_call(mocker, tubular.base.BaseTransformer,
"check_is_fitted", expected_call_args):
x.transform(df)
def test_super_transform_call(self, mocker):
"""Test that call the BaseTransformer.transform() is as expected."""
df = d.create_is_between_dates_df_1()
x = BetweenDatesTransformer(column_lower="a",
column_between="b",
column_upper="c",
new_column_name="d")
expected_call_args = {
0: {
"args": (d.create_is_between_dates_df_1(), ),
"kwargs": {}
}
}
with h.assert_function_call(
mocker,
tubular.base.BaseTransformer,
"transform",
expected_call_args,
return_value=d.create_is_between_dates_df_1(),
):
x.transform(df)
def test_super_init_called(self, mocker):
"""Test that init calls BaseTransformer.init."""
expected_call_args = {
0: {
"args": (),
"kwargs": {
"columns": ["dummy_1", "dummy_2"],
"verbose": True,
"copy": True,
},
}
}
with h.assert_function_call(mocker, tubular.base.BaseTransformer,
"__init__", expected_call_args):
DateDiffLeapYearTransformer(
column_lower="dummy_1",
column_upper="dummy_2",
new_column_name="dummy_3",
drop_cols=True,
verbose=True,
copy=True,
)
def test_super_transform_called(self, mocker):
"""Test that BaseTransformer.transform called."""
df = d.create_date_test_df()
x = DateDiffLeapYearTransformer(column_lower="a",
column_upper="b",
new_column_name="c",
drop_cols=True)
expected_call_args = {
0: {
"args": (d.create_date_test_df(), ),
"kwargs": {}
}
}
with h.assert_function_call(
mocker,
tubular.base.BaseTransformer,
"transform",
expected_call_args,
return_value=d.create_date_test_df(),
):
x.transform(df)
def test_super_transform_called(self, mocker):
"""Test that BaseImputer.transform called."""
df = d.create_df_2()
x = ArbitraryImputer(impute_value=1, columns="a")
expected_call_args = {0: {"args": (d.create_df_2(), ), "kwargs": {}}}
with h.assert_function_call(mocker, tubular.imputers.BaseImputer,
"transform", expected_call_args):
x.transform(df)
def test_check_is_fitted_called(self, mocker):
"""Test that BaseTransformer check_is_fitted called."""
df = d.create_df_1()
x = ArbitraryImputer(impute_value=1, columns="a")
expected_call_args = {0: {"args": (["impute_value"], ), "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_7()
x = SetValueTransformer(columns=["a", "b"], value=1)
expected_call_args = {0: {"args": (d.create_df_7(), ), "kwargs": {}}}
with h.assert_function_call(mocker, tubular.base.BaseTransformer,
"transform", expected_call_args):
x.transform(df)
def test_super_transform_called(self, mocker):
"""Test that BaseTransformer.transform called."""
df = d.create_df_1()
x = NullIndicator(columns="a")
expected_call_args = {0: {"args": (d.create_df_1(), ), "kwargs": {}}}
with h.assert_function_call(mocker, tubular.base.BaseTransformer,
"transform", expected_call_args):
x.transform(df)
def test_super_columns_check_called(self, mocker):
"""Test that BaseTransformer.columns_check called."""
df = d.create_df_2()
x = ArbitraryImputer(impute_value=-1, columns="a")
expected_call_args = {0: {"args": (d.create_df_2(), ), "kwargs": {}}}
with h.assert_function_call(mocker, tubular.base.BaseTransformer,
"columns_check", expected_call_args):
x.transform(df)
def test_columns_check_called(self, mocker):
"""Test that self.columns_check is called during transform."""
df = d.create_df_1()
x = BaseTransformer(columns="a")
expected_call_args = {0: {"args": (df,), "kwargs": {}}}
with h.assert_function_call(
mocker, tubular.base.BaseTransformer, "columns_check", expected_call_args
):
x.transform(X=df)
def test_df_copy_called(self, mocker):
"""Test pd.DataFrame.copy is called if copy is True."""
df = d.create_df_1()
x = BaseTransformer(columns="a", copy=True)
expected_call_args = {0: {"args": (), "kwargs": {}}}
with h.assert_function_call(
mocker, pandas.DataFrame, "copy", expected_call_args, return_value=df
):
x.transform(X=df)
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_7()
x = SeriesStrMethodTransformer(new_column_name="cc",
pd_method_name="find",
columns=["c"])
expected_call_args = {0: {"args": (d.create_df_7(), ), "kwargs": {}}}
with h.assert_function_call(mocker, tubular.base.BaseTransformer,
"transform", expected_call_args):
x.transform(df)
def test_super_transform_called(self, mocker):
"""Test that BaseImputer.transform called."""
df = d.create_df_2()
x = BaseImputer()
x.columns = []
x.impute_values_ = {}
expected_call_args = {0: {"args": (d.create_df_2(), ), "kwargs": {}}}
with h.assert_function_call(mocker, tubular.base.BaseTransformer,
"transform", expected_call_args):
x.transform(df)
def test_check_is_fitted_call(self, mocker):
"""Test the call to check_is_fitted."""
df = d.create_df_1()
mapping = {"a": {1: "a", 2: "b", 3: "c", 4: "d", 5: "e", 6: "f"}}
x = CrossColumnMappingTransformer(mappings=mapping, adjust_column="b")
expected_call_args = {0: {"args": (["adjust_column"],), "kwargs": {}}}
with h.assert_function_call(
mocker, tubular.base.BaseTransformer, "check_is_fitted", expected_call_args
):
x.transform(df)
def test_super_fit_call(self, mocker):
"""Test the call to BaseTransformer.fit."""
df = d.create_df_9()
x = CappingTransformer(
quantiles={"a": [0.1, 1], "b": [0.5, None]}, weights_column="c"
)
expected_call_args = {0: {"args": (d.create_df_9(), None), "kwargs": {}}}
with h.assert_function_call(
mocker, tubular.base.BaseTransformer, "fit", expected_call_args
):
x.fit(df)
def test_check_is_fitted_call(self, mocker):
"""Test the call to check_is_fitted."""
df = d.create_df_1()
mapping = {"b": {"a": 1.1, "b": 1.2, "c": 1.3, "d": 1.4, "e": 1.5, "f": 1.6}}
x = CrossColumnMultiplyTransformer(mappings=mapping, adjust_column="a")
expected_call_args = {0: {"args": (["adjust_column"],), "kwargs": {}}}
with h.assert_function_call(
mocker, tubular.base.BaseTransformer, "check_is_fitted", expected_call_args
):
x.transform(df)
def test_columns_check_call(self, mocker):
"""Test the first call to BaseTransformer columns_check."""
df = d.create_df_1()
x = OneHotEncodingTransformer(columns="b")
x.fit(df)
expected_call_args = {0: {"args": (d.create_df_1(),), "kwargs": {}}}
with h.assert_function_call(
mocker, tubular.base.BaseTransformer, "columns_check", expected_call_args
):
x.transform(df)
