No warning test case added

Author: Boluwatife28

CHANGELOG.rst

@@ -38,9 +38,12 @@ Changed
 - narwhalified DropOriginalMixin `#352 <https://github.com/lvgig/tubular/issues/352>_`
 - narwhalified BaseMappingTransformer `#367 <https://github.com/lvgig/tubular/issues/367>_`
 - narwhalified BaseDatetimeTransformer `#375 <https://github.com/azukds/tubular/issues/375>`
+- Optional wanted_levels feature has been integrated into the OneHotEncodingTransformer which allows users to specify which levels in a column they wish to encode. `#384 <https://github.com/azukds/tubular/issues/384>_`
+- Created unit tests to check if the values provided for wanted_values are as expected and if the output is as expected.
 - placeholder
 - placeholder
-- placeholder
+
+
 
 1.4.1 (02/12/2024)
 ------------------

tests/nominal/test_OneHotEncodingTransformer.py

@@ -38,7 +38,7 @@ def test_wanted_values_is_dict(self, values, minimal_attribute_dict):
 
         with pytest.raises(
             TypeError,
-            match="OneHotEncodingTransformer: Wanted_values should be a dictionary",
+            match="OneHotEncodingTransformer: wanted_values should be a dictionary",
         ):
             OneHotEncodingTransformer(**args)
 
@@ -131,7 +131,8 @@ def test_fit_missing_levels_warning(self, library):
         df = d.create_df_1(library=library)
 
         transformer = OneHotEncodingTransformer(
-            columns=["b"], wanted_values={"b": ["f", "g"]}
+            columns=["b"],
+            wanted_values={"b": ["f", "g"]},
         )
 
         with pytest.warns(
@@ -160,6 +161,21 @@ def test_fields_with_over_100_levels_error(self, library):
         ):
             transformer.fit(df)
 
+    @pytest.mark.parametrize(
+        "library",
+        ["pandas", "polars"],
+    )
+    def test_fit_no_warning_if_all_wanted_values_present(self, library):
+        """Test that OneHotEncodingTransformer.fit does NOT raise a warning when all levels in wanted_levels are present in the data."""
+        df = d.create_df_1(library=library)
+
+        transformer = OneHotEncodingTransformer(
+            columns=["b"], wanted_values={"b": ["a", "b", "c", "d", "e", "f"]}
+        )
+
+        with pytest.warns(None):
+            transformer.fit(df)
+
 
 class TestTransform(
     DropOriginalTransformMixinTests,
@@ -378,7 +394,8 @@ def test_transform_missing_levels_warning(self, library):
         df_test = d.create_df_8(library=library)
 
         transformer = OneHotEncodingTransformer(
-            columns=["b"], wanted_values={"b": ["v", "x", "z"]}
+            columns=["b"],
+            wanted_values={"b": ["v", "x", "z"]},
         )
 
         transformer.fit(df_train)
@@ -433,42 +450,64 @@ def test_unseen_categories_encoded_as_all_zeroes(self, library):
                 df_expected_row,
             )
 
-
     @pytest.mark.parametrize(
         "library",
         ["pandas", "polars"],
     )
-    def test_transform_missing_levels_encoded_as_all_zeroes(self, library):
-        """Test OneHotEncodingTransformer.transform triggers a warning for missing levels."""
+    def test_transform_output_with_wanted_values_arg(self, library):
+        """
+        Test to verify OneHotEncodingTransformer.transform zero-filled levels from user-specified "wanted_levels" and encodes only those listed in "wanted_levels".
+
+        """
         df_train = d.create_df_7(library=library)
         df_test = d.create_df_8(library=library)
 
         transformer = OneHotEncodingTransformer(
-            columns=["b"], wanted_values={"b": ["v", "x", "z"]}
+            columns=["b"],
+            wanted_values={"b": ["v", "x", "z"]},
         )
 
         transformer.fit(df_train)
         df_transformed = transformer.transform(df_test)
 
-        expected_df_dict= {
+        expected_df_dict = {
             "a": [1, 5, 2, 3, 3],
             "b": ["w", "w", "z", "y", "x"],
             "c": ["a", "a", "c", "b", "a"],
-            "b_v": [0]*5,
-            "b_x": [0,0,0,0,1],
-            "b_z":[0,0,1,0,0],
+            "b_v": [0] * 5,
+            "b_x": [0, 0, 0, 0, 1],
+            "b_z": [0, 0, 1, 0, 0],
         }
-        expected_df = dataframe_init_dispatch(library=library, dataframe_dict=expected_df_dict)
+        expected_df = dataframe_init_dispatch(
+            library=library,
+            dataframe_dict=expected_df_dict,
+        )
         expected_df = nw.from_native(expected_df)
         # cast the columns
-        boolean_cols= ["b_v", "b_x", "b_z"]
+        boolean_cols = ["b_v", "b_x", "b_z"]
         for col_name in boolean_cols:
-            expected_df= expected_df.with_columns(
-                nw.col(col_name).cast(nw.Boolean)
+            expected_df = expected_df.with_columns(
+                nw.col(col_name).cast(nw.Boolean),
             )
-        expected_df= expected_df.with_columns(
-            nw.col("c").cast(nw.Categorical)
+        expected_df = expected_df.with_columns(
+            nw.col("c").cast(nw.Categorical),
         )
 
         assert_frame_equal_dispatch(df_transformed, expected_df.to_native())
- 
+
+    @pytest.mark.parametrize(
+        "library",
+        ["pandas", "polars"],
+    )
+    def test_transform_no_warning_if_all_wanted_values_present(self, library):
+        """Test that OneHotEncodingTransformer.transform does NOT raise a warning when all levels in wanted_levels are present in the data."""
+        df_train = d.create_df_7(library=library)
+        df_test = d.create_df_8(library=library)
+
+        transformer = OneHotEncodingTransformer(
+            columns=["b"], wanted_values={"b": ["x", "z", "y"]}
+        )
+        transformer.fit(df_train)
+
+        with pytest.warns(None):
+            transformer.transform(df_test)

tubular/nominal.py

@@ -1143,7 +1143,7 @@ def __init__(
 
         if wanted_values is not None:
             if not isinstance(wanted_values, dict):
-                msg = f"{self.classname()}: Wanted_values should be a dictionary"
+                msg = f"{self.classname()}: wanted_values should be a dictionary"
                 raise TypeError(msg)
 
             for key, val_list in wanted_values.items():
@@ -1225,7 +1225,7 @@ def fit(self, X: FrameT, y: nw.Series | None = None) -> FrameT:
             self.categories_[c] = final_categories
             self.new_feature_names_[c] = self._get_feature_names(column=c)
 
-            present_levels = set(X.select(nw.col(c).unique()).get_column(c).to_list())
+            present_levels = set(X.get_column(c).unique().to_list())
             missing_levels = self._warn_missing_levels(
                 present_levels,
                 c,
@@ -1239,12 +1239,24 @@ def _warn_missing_levels(
         present_levels: list,
         c: str,
         missing_levels: dict[str, list[str]],
-    ) -> list:
+    ) -> dict[str, list[str]]:
+        """Logs a warning for user-specifed levels that are not found in the dataset and updates "missing_levels[c]" with those missing levels.
+
+        Parameters
+        ----------
+        present_levels: list
+            List of levels observed in the data.
+        c: str
+            The column name being checked for missing user-specified levels.
+        missing_levels: dict[str, list[str]]
+            Dictionary containing missing user-specified levels for each column.
+
+        """
         # print warning for missing levels
         missing_levels[c] = list(
             set(self.categories_[c]).difference(present_levels),
         )
-        if len(missing_levels) > 0:
+        if len(missing_levels[c]) > 0:
             warning_msg = f"{self.classname()}: column {c} includes user-specified values {missing_levels[c]} not found in the dataset"
             warnings.warn(warning_msg, UserWarning, stacklevel=2)
 
@@ -1300,7 +1312,7 @@ def transform(self, X: FrameT) -> FrameT:
                 )
 
             # print warning for unseen levels
-            present_levels = set(X.select(nw.col(c).unique()).get_column(c).to_list())
+            present_levels = set(X.get_column(c).unique().to_list())
             unseen_levels = present_levels.difference(set(self.categories_[c]))
             if len(unseen_levels) > 0:
                 warning_msg = f"{self.classname()}: column {c} has unseen categories: {unseen_levels}"