def test_impute_values_set_to_attribute(self):
"""Test that the value passed for impute_value is saved in an attribute of the same name."""
x = LogTransformer(
columns=["a", "b"],
base=1,
add_1=True,
drop=False,
suffix="new",
verbose=True,
copy=True,
)
expected_attributes = {
"base": 1,
"add_1": True,
"drop": False,
"suffix": "new"
}
h.test_object_attributes(
obj=x,
expected_attributes=expected_attributes,
msg="Attributes for LogTransformer set in init",
)
def test_assert_equal_dispatch_calls():
"""Test the call arguments to assert_equal_dispatch."""
x = DummyClass()
expected_attributes = {"a": 1, "b": 2, "c": 3}
call_n = 0
with mock.patch(target="tubular.testing.helpers.assert_equal_dispatch"
) as mocked_method:
h.test_object_attributes(obj=x,
expected_attributes=expected_attributes,
msg="test_msg")
call_n = 0
for k, v in expected_attributes.items():
call_n_args = mocked_method.call_args_list[call_n]
call_n_pos_args = call_n_args[0]
call_n_kwargs = call_n_args[1]
expected_pos_args = ()
expected_kwargs = {
"expected": v,
"actual": getattr(x, k),
"msg": f"{k} test_msg",
}
assert (
call_n_pos_args == expected_pos_args
), f"Unexpected call positional args in call {call_n} -\n Expected: None\n Actual: {call_n_pos_args}"
assert len(call_n_kwargs.keys()) == len(
expected_kwargs.keys()
), f"Difference in number of positional arguments in call {call_n} -\n Expected: {len(call_n_kwargs.keys())}\n Actual: {len(expected_kwargs.keys())}"
keys_diff_e_a = set(expected_kwargs.keys()) - set(
call_n_kwargs.keys())
keys_diff_a_e = set(call_n_kwargs.keys()) - set(
expected_kwargs.keys())
assert (
keys_diff_e_a == set()
), f"Keys in expected not in actual: {keys_diff_e_a}\nKeys in actual not in expected: {keys_diff_a_e}"
for k in expected_kwargs.keys():
e = expected_kwargs[k]
a = call_n_kwargs[k]
assert (
e == a
), f"Difference in keyword arg {k} -\n Expected: {e}\n Actual: {a}"
call_n += 1
def test_prepare_quantiles_output_set_attributes(self, mocker, weights_column):
"""Test the output of prepare_quantiles is set to capping_values and_replacement_values attributes."""
df = d.create_df_9()
x = CappingTransformer(
quantiles={"a": [0.1, 1], "b": [0.5, None]}, weights_column=weights_column
)
mocked_return_values = [["aaaa", "bbbb"], [1234, None]]
mocker.patch(
"tubular.capping.CappingTransformer.prepare_quantiles",
side_effect=mocked_return_values,
)
x.fit(df)
h.test_object_attributes(
obj=x,
expected_attributes={
"capping_values": {
"a": mocked_return_values[0],
"b": mocked_return_values[1],
},
"_replacement_values": {
"a": mocked_return_values[0],
"b": mocked_return_values[1],
},
},
msg="weighted_quantile output set to capping_values, _replacement_values attributes",
)
def test_expected_attributes_non_dict_error():
"""Test that a TypeError is raised if expected_attributes passed as not a dict."""
x = DummyClass()
with pytest.raises(TypeError):
h.test_object_attributes(obj=x,
expected_attributes=(1, 2),
msg="test_msg")
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 = OrdinalEncoderTransformer(response_column="aaa")
h.test_object_attributes(
obj=x,
expected_attributes={"response_column": "aaa"},
msg="Attributes for OrdinalEncoderTransformer set in init",
)
def test_columns_str_to_list(self):
"""Test columns is converted to list if passed as string."""
x = BaseTransformer(columns="a")
expected_attributes = {"columns": ["a"]}
h.test_object_attributes(
obj=x,
expected_attributes=expected_attributes,
msg="String put in list for columns",
)
def test_expected_attribute_missing_error():
"""Test that an AssertionError is raised if an excpeted attribute is missing from object."""
x = DummyClass()
expected_attributes = {"a": 1, "b": 2, "c": 3, "d": 4}
with pytest.raises(AssertionError, match="obj has not attribute d"):
h.test_object_attributes(obj=x,
expected_attributes=expected_attributes,
msg="test_msg")
def test_expected_attribute_wrong_error():
"""Test that an AssertionError is raised if an excpeted attribute value is wrong."""
x = DummyClass()
expected_attributes = {"a": 1, "b": 2, "c": 10}
with pytest.raises(AssertionError, match=f"""{'c'} {'test_msg'}"""):
h.test_object_attributes(obj=x,
expected_attributes=expected_attributes,
msg="test_msg")
def test_mappings_set_to_attribute(self):
"""Test that the value passed for mappings is saved in an attribute of the same name."""
value = {"a": {"a": 1}, "b": {"a": 1}}
x = BaseMappingTransformer(mappings=value)
h.test_object_attributes(
obj=x,
expected_attributes={"mappings": value},
msg="Attributes for BaseMappingTransformer set in init",
)
def test_adjust_column_set_to_attribute(self):
"""Test that the value passed for adjust_column is saved in an attribute of the same name."""
value = "b"
x = CrossColumnMappingTransformer(mappings={"a": {"a": 1}}, adjust_column=value)
h.test_object_attributes(
obj=x,
expected_attributes={"adjust_column": value},
msg="Attributes for CrossColumnMappingTransformer set in init",
)
def test_start_encoding_set_to_attribute(self):
"""Test that the value passed for start_encoding is saved in an attribute of the same name."""
value = 1
x = NominalToIntegerTransformer(start_encoding=value)
h.test_object_attributes(
obj=x,
expected_attributes={"start_encoding": value},
msg="Attributes for NominalToIntegerTransformer set in init",
)
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 = OneHotEncodingTransformer(
columns=None, verbose=True, copy=True, separator="x", drop_original=True
)
h.test_object_attributes(
obj=x,
expected_attributes={"separator": "x", "drop_original": True},
msg="Attributes for OneHotEncodingTransformer set in init",
)
def test_attributes_set(self):
"""Test that the values passed for new_column_name, pd_method_name are saved to attributes on the object."""
x = DataFrameMethodTransformer(new_column_name="a",
pd_method_name="sum",
columns=["b", "c"])
h.test_object_attributes(
obj=x,
expected_attributes={
"new_column_name": "a",
"pd_method_name": "sum"
},
msg="Attributes for DataFrameMethodTransformer set in init",
)
def test_impute_values_set_to_attribute(self):
"""Test that the value passed for impute_value is saved in an attribute of the same name."""
value = 1
x = ArbitraryImputer(impute_value=value, columns="a")
h.test_object_attributes(
obj=x,
expected_attributes={
"impute_value": value,
"impute_values_": {}
},
msg="Attributes for ArbitraryImputer set in init",
)
def test_callable_attribute_set(self, pd_method_name, callable_attr):
"""Test the _callable attribute is set to True if pd.Series.dt.pd_method_name is callable."""
x = SeriesDtMethodTransformer(
new_column_name="a",
pd_method_name=pd_method_name,
column="b",
pd_method_kwargs={"d": 1},
)
h.test_object_attributes(
obj=x,
expected_attributes={"_callable": callable_attr},
msg="_callable attribute for SeriesDtMethodTransformer set in init",
)
def test_learnt_values_not_modified(self):
"""Test that the replacements from fit are not changed in transform."""
capping_values_dict = {"a": [2, 5], "b": [-1, 8]}
df = d.create_df_3()
x = CappingTransformer(capping_values_dict)
x.transform(df)
h.test_object_attributes(
obj=x,
expected_attributes={"capping_values": capping_values_dict},
msg="Attributes for CappingTransformer set in init",
)
def test_attributes_set_from_passed_values(self):
"""Test attributes set from values passed in init have the correct values."""
expected_attributes = {
"columns": ["a", "b", "c"],
"copy": False,
"verbose": True,
}
x = BaseTransformer(**expected_attributes)
h.test_object_attributes(
obj=x,
expected_attributes=expected_attributes,
msg="Attributes set in init from passed values",
)
def test_impute_value_unchanged(self):
"""Test that self.impute_value is unchanged after transform."""
df = d.create_df_1()
value = 1
x = ArbitraryImputer(impute_value=value, columns="a")
x.transform(df)
h.test_object_attributes(
obj=x,
expected_attributes={"impute_value": value},
msg="impute_value changed in transform",
)
def test_getattr_calls():
"""Test the call arguments to getattr."""
x = DummyClass()
expected_attributes = {"a": 1, "b": 2, "c": 3}
call_n = 0
with mock.patch(target="tubular.testing.helpers.getattr") as mocked_method:
# again mock assert_equal_dispatch (called by test_object_attributes) so it does not error from
# getattr not returning the right things - as it is mocked
with mock.patch(
target="tubular.testing.helpers.assert_equal_dispatch"):
h.test_object_attributes(obj=x,
expected_attributes=expected_attributes,
msg="msg")
call_n = 0
for k, v in expected_attributes.items():
call_n_args = mocked_method.call_args_list[call_n]
call_n_pos_args = call_n_args[0]
call_n_kwargs = call_n_args[1]
expected_pos_args = (x, k)
assert (
call_n_kwargs == {}
), f"Unexpected call keyword args in call {call_n} -\n Expected: None\n Actual: {call_n_kwargs}"
assert len(call_n_pos_args) == len(
expected_pos_args
), f"Difference in number of positional arguments in call {call_n} -\n Expected: {len(expected_pos_args)}\n Actual: {len(call_n_pos_args)}"
for i, (e,
a) in enumerate(zip(expected_pos_args,
call_n_pos_args)):
assert (
e == a
), f"Difference in positional args at index {i} in call {call_n} -\n Expected: {e}\n Actual: {a}"
call_n += 1
def test_default_attributes_set_in_init(self):
"""Test correct default values for attributes set in init."""
x = BaseTransformer()
expected_attributes = {
"version_": tubular._version.__version__,
"verbose": False,
"columns": None,
"copy": True,
}
h.test_object_attributes(
obj=x,
expected_attributes=expected_attributes,
msg="Default attributes set in init",
)
def test_n_assert_equal_dispatch_calls():
"""Test the number of calls to tubular.testing.helpers.assert_equal_dispatch."""
x = DummyClass()
expected_attributes = {"a": 1, "b": 2, "c": 3}
with mock.patch(target="tubular.testing.helpers.assert_equal_dispatch"
) as mocked_method:
h.test_object_attributes(obj=x,
expected_attributes=expected_attributes,
msg="msg")
assert mocked_method.call_count == len(
expected_attributes.keys()
), f"Unexpected number of calls to hasattr -\n Expected: {len(expected_attributes.keys())}\n Actual: {mocked_method.call_count}"
def test_values_passed_in_init_set_to_attribute_quantiles(self):
"""Test that the capping_values passed in init are saved in an attribute of the same name."""
quantiles_dict = {"a": [0.2, 1], "b": [None, 0.9]}
x = CappingTransformer(quantiles=quantiles_dict)
h.test_object_attributes(
obj=x,
expected_attributes={
"quantiles": quantiles_dict,
"weights_column": None,
"capping_values": {},
"_replacement_values": {},
},
msg="quantiles attribute for CappingTransformer set in init",
)
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_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_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_learnt_values(self):
"""Test that the impute values learnt during fit are expected."""
df = d.create_df_3()
x = ModeImputer(columns=["a", "b", "c"])
x.fit(df)
h.test_object_attributes(
obj=x,
expected_attributes={
"impute_values_": {
"a": df["a"].mode()[0],
"b": df["b"].mode()[0],
"c": df["c"].mode()[0],
}
},
msg="impute_values_ attribute",
)
def test_attributes_set(self):
"""Test that the values passed for new_column_name, pd_method_name are saved to attributes on the object."""
x = SeriesStrMethodTransformer(
new_column_name="a",
pd_method_name="find",
columns=["b"],
pd_method_kwargs={"d": 1},
)
h.test_object_attributes(
obj=x,
expected_attributes={
"new_column_name": "a",
"pd_method_name": "find",
"pd_method_kwargs": {
"d": 1
},
},
msg="Attributes for SeriesStrMethodTransformer set in init",
)
def test_n_getattr_calls():
"""Test the number of calls to getattr."""
x = DummyClass()
expected_attributes = {"a": 1, "b": 2, "c": 3}
with mock.patch(target="tubular.testing.helpers.getattr") as mocked_method:
# mock assert_equal_dispatch (called by test_object_attributes) so it does not error from
# getattr not returning the right things - as it is mocked
with mock.patch(
target="tubular.testing.helpers.assert_equal_dispatch"):
h.test_object_attributes(obj=x,
expected_attributes=expected_attributes,
msg="msg")
assert mocked_method.call_count == len(
expected_attributes.keys()
), f"Unexpected number of calls to hasattr -\n Expected: {len(expected_attributes.keys())}\n Actual: {mocked_method.call_count}"
def test_learnt_values(self):
"""Test that the impute values learnt during fit are expected."""
df = d.create_df_1()
x = NominalToIntegerTransformer(columns=["a", "b"], start_encoding=1)
x.fit(df)
h.test_object_attributes(
obj=x,
expected_attributes={
"mappings": {
"a": {k: i
for i, k in enumerate(df["a"].unique(), 1)},
"b": {k: i
for i, k in enumerate(df["b"].unique(), 1)},
}
},
msg="mappings attribute",
)
def test_values_passed_in_init_set_to_attribute(self):
"""Test that attributes are set by init."""
x = BetweenDatesTransformer(
column_lower="a",
column_between="b",
column_upper="c",
new_column_name="d",
lower_inclusive=False,
upper_inclusive=False,
)
h.test_object_attributes(
obj=x,
expected_attributes={
"columns": ["a", "b", "c"],
"new_column_name": "d",
"lower_inclusive": False,
"upper_inclusive": False,
},
msg="Attributes for BetweenDatesTransformer set in init",
)
