feat: discretize table

src/safeds/data/tabular/transformation/_discretizer.py

@@ -4,7 +4,7 @@
 
 from safeds.data.tabular.containers import Table
 from safeds.data.tabular.transformation._table_transformer import TableTransformer
-from safeds.exceptions import TransformerNotFittedError, UnknownColumnNameError
+from safeds.exceptions import NonNumericColumnError, TransformerNotFittedError, UnknownColumnNameError
 
 
 class Discretizer(TableTransformer):
@@ -47,14 +47,30 @@ def fit(self, table: Table, column_names: list[str] | None) -> Discretizer:
         -------
         fitted_transformer : TableTransformer
             The fitted transformer.
+
+        Raises
+        ------
+        ValueError
+            If the table is empty.
+        NonNumericColumnError
+            If one of the columns, that should be fitted is not numeric.
+        UnknownColumnNameError
+            If one of the columns, that should be fitted is not in the table.
         """
+        if table.number_of_rows == 0:
+            raise ValueError("The Discretizer cannot be fitted because the table contains 0 rows")
+
         if column_names is None:
             column_names = table.column_names
         else:
             missing_columns = set(column_names) - set(table.column_names)
             if len(missing_columns) > 0:
                 raise UnknownColumnNameError(list(missing_columns))
 
+            for column in column_names:
+                if not table.get_column(column).type.is_numeric():
+                    raise NonNumericColumnError(f"{column} is of type {table.get_column(column).type}.")
+
         wrapped_transformer = sk_KBinsDiscretizer(n_bins=self._number_of_bins, encode="ordinal")
         wrapped_transformer.fit(table._data[column_names])
 
@@ -84,16 +100,27 @@ def transform(self, table: Table) -> Table:
         ------
         TransformerNotFittedError
             If the transformer has not been fitted yet.
+        ValueError
+            If the table is empty.
+        NonNumericColumnError
+            If one of the columns, that should be fitted is not numeric.
         """
         # Transformer has not been fitted yet
         if self._wrapped_transformer is None or self._column_names is None:
             raise TransformerNotFittedError
 
+        if table.number_of_rows == 0:
+            raise ValueError("The table cannot be transformed because it contains 0 rows")
+
         # Input table does not contain all columns used to fit the transformer
         missing_columns = set(self._column_names) - set(table.column_names)
         if len(missing_columns) > 0:
             raise UnknownColumnNameError(list(missing_columns))
 
+        for column in self._column_names:
+            if not table.get_column(column).type.is_numeric():
+                raise NonNumericColumnError(f"{column} is of type {table.get_column(column).type}.")
+
         data = table._data.copy()
         data.columns = table.column_names
         data[self._column_names] = self._wrapped_transformer.transform(data[self._column_names])

tests/safeds/data/tabular/transformation/test_discretizer.py

@@ -1,7 +1,7 @@
 import pytest
 from safeds.data.tabular.containers import Table
 from safeds.data.tabular.transformation import Discretizer
-from safeds.exceptions import TransformerNotFittedError, UnknownColumnNameError
+from safeds.exceptions import NonNumericColumnError, TransformerNotFittedError, UnknownColumnNameError
 
 
 class TestInit:
@@ -11,14 +11,34 @@ def test_should_raise_value_error(self) -> None:
 
 
 class TestFit:
-    def test_should_raise_if_column_not_found(self) -> None:
-        table = Table(
-            {
-                "col1": [0.0, 5.0, 10.0],
-            },
-        )
-
-        with pytest.raises(UnknownColumnNameError):
+    @pytest.mark.parametrize(
+        ("table", "error", "error_message"),
+        [
+            (
+                Table(
+                    {
+                        "col1": [0.0, 5.0, 5.0, 10.0],
+                    },
+                ),
+                UnknownColumnNameError,
+                r"Could not find column\(s\) 'col2'",
+            ),
+            (Table(), ValueError, "The Discretizer cannot be fitted because the table contains 0 rows"),
+            (
+                Table(
+                    {
+                        "col1": [0.0, 5.0, 5.0, 10.0],
+                        "col2": ["a", "b", "c", "d"],
+                    },
+                ),
+                NonNumericColumnError,
+                "Tried to do a numerical operation on one or multiple non-numerical columns: \ncol2 is of type String.",
+            ),
+        ],
+        ids=["UnknownColumnNameError", "ValueError", "NonNumericColumnError"],
+    )
+    def test_should_raise_errors(self, table: Table, error: type[Exception], error_message: str) -> None:
+        with pytest.raises(error, match=error_message):
             Discretizer().fit(table, ["col2"])
 
     def test_should_not_change_original_transformer(self) -> None:
@@ -36,7 +56,32 @@ def test_should_not_change_original_transformer(self) -> None:
 
 
 class TestTransform:
-    def test_should_raise_if_column_not_found(self) -> None:
+    @pytest.mark.parametrize(
+        ("table_to_transform", "error", "error_message"),
+        [
+            (
+                Table(
+                    {
+                        "col2": ["a", "b", "c"],
+                    },
+                ),
+                UnknownColumnNameError,
+                r"Could not find column\(s\) 'col1'",
+            ),
+            (Table(), ValueError, "The table cannot be transformed because it contains 0 rows"),
+            (
+                Table(
+                    {
+                        "col1": ["a", "b", "c", "d"],
+                    },
+                ),
+                NonNumericColumnError,
+                "Tried to do a numerical operation on one or multiple non-numerical columns: \ncol1 is of type String.",
+            ),
+        ],
+        ids=["UnknownColumnNameError", "ValueError", "NonNumericColumnError"],
+    )
+    def test_should_raise_errors(self, table_to_transform: Table, error: type[Exception], error_message: str) -> None:
         table_to_fit = Table(
             {
                 "col1": [0.0, 5.0, 10.0],
@@ -45,13 +90,7 @@ def test_should_raise_if_column_not_found(self) -> None:
 
         transformer = Discretizer().fit(table_to_fit, None)
 
-        table_to_transform = Table(
-            {
-                "col2": ["a", "b", "c"],
-            },
-        )
-
-        with pytest.raises(UnknownColumnNameError):
+        with pytest.raises(error, match=error_message):
             transformer.transform(table_to_transform)
 
     def test_should_raise_if_not_fitted(self) -> None: