feat: add SequentialTableTransformer

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

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from typing import TYPE_CHECKING
+from warnings import warn
 
 from safeds._utils import _structural_hash
 from safeds.exceptions import TransformerNotFittedError, TransformerNotInvertibleError
@@ -25,20 +26,25 @@
     Raises
     ------
     ValueError:
-        Raises a ValueError if the list of Transformers is None or contains no transformers.
+        Raises a ValueError if the list of Transformers is None.
     """
 
     def __init__(
         self,
         transformers: list[TableTransformer],
-        *,
-        column_names: str | list[str] | None = None,  # noqa: ARG002
     ) -> None:
         super().__init__(None)
 
+        if transformers is None:
+            raise ValueError("transformers can't be None")
+
         # Check if transformers actually contains any transformers.
         if transformers is None or len(transformers) == 0:
-            raise ValueError("transformers must contain at least 1 transformer")
+            warn(
+                ("transformers should contain at least 1 transformer"),
+                UserWarning,
+                stacklevel=2,
+            )
 
         # Parameters
         self._transformers: list[TableTransformer] = transformers
@@ -95,7 +101,6 @@
 
         result: SequentialTableTransformer = SequentialTableTransformer(
             transformers=fitted_transformers,
-            column_names=self._column_names,
         )
 
         result._is_fitted = True

tests/helpers/_assertions.py

@@ -13,7 +13,7 @@ def assert_tables_equal(
     ignore_column_order: bool = False,
     ignore_row_order: bool = False,
     ignore_types: bool = False,
-    check_exact: bool = False,
+    ignore_float_imprecision: bool = True,
 ) -> None:
     """
     Assert that two tables are almost equal.
@@ -30,16 +30,16 @@ def assert_tables_equal(
         Ignore the column order when True. Will return true, even when the row order is different.
     ignore_types:
         Ignore differing data Types. Will return true, even when columns have differing data types.
-    check_exact:
-        If True, check, if floating point values match EXACTLY.
+    ignore_float_imprecision:
+        If False, check if floating point values match EXACTLY.
     """
     assert_frame_equal(
         table1._data_frame,
         table2._data_frame,
         check_row_order=not ignore_row_order,
         check_column_order=not ignore_column_order,
         check_dtypes=not ignore_types,
-        check_exact=check_exact,
+        check_exact=not ignore_float_imprecision,
     )
 
 

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

@@ -16,30 +16,27 @@
 
 class TestInit:
 
-    def test_should_raise_value_error_on_empty_list(self) -> None:
-        with pytest.raises(ValueError, match=("transformers must contain at least 1 transformer")):
-            SequentialTableTransformer(transformers=[])  # type: ignore  # noqa: PGH003
+    def test_should_warn_on_empty_list(self) -> None:
+        with pytest.warns(UserWarning, match=("transformers should contain at least 1 transformer")):
+            SequentialTableTransformer(transformers=[])  # type: ignore[attr-defined]
 
 
 class TestFit:
     def test_should_raise_value_error_on_empty_table(self) -> None:
-        one_hot = OneHotEncoder()
-        imputer = SimpleImputer(SimpleImputer.Strategy.constant(0))
-        transformers = [one_hot, imputer]
         test_table = Table(
             {
                 "col1": [],
                 "col2": [],
             },
         )
-        sequential_table_transformer = SequentialTableTransformer(transformers)
+        sequential_table_transformer = SequentialTableTransformer([SimpleImputer(SimpleImputer.Strategy.constant(0))])
         with pytest.raises(
             ValueError,
             match=("The SequentialTableTransformer cannot be fitted because the table contains 0 rows."),
         ):
             sequential_table_transformer.fit(test_table)
 
-    def test_fit_does_not_change_original_transformer(self) -> None:
+    def test_should_not_change_original_transformer(self) -> None:
         one_hot = OneHotEncoder()
         imputer = SimpleImputer(SimpleImputer.Strategy.constant(0))
         transformer_list = [one_hot, imputer]
@@ -94,7 +91,7 @@ def test_should_do_same_as_transformer_with_single_transformer(self, transformer
         test_table_sequential = sequential_transformer.transform(test_table)
         assert_tables_equal(test_table_normal, test_table_sequential)
 
-    def test_transforms_correctly_with_multiple_transformers(self) -> None:
+    def test_should_transform_with_multiple_transformers(self) -> None:
         one_hot = OneHotEncoder()
         imputer = SimpleImputer(SimpleImputer.Strategy.constant(0))
         transformers = [one_hot, imputer]
@@ -106,25 +103,25 @@ def test_transforms_correctly_with_multiple_transformers(self) -> None:
         )
         sequential_table_transformer = SequentialTableTransformer(transformers)
         fitted_sequential_table_transformer = sequential_table_transformer.fit(test_table)
-        transfromed_table_sequential = fitted_sequential_table_transformer.transform(test_table)
+        transformed_table_sequential = fitted_sequential_table_transformer.transform(test_table)
 
         one_hot = one_hot.fit(test_table)
-        transormed_table_individual = one_hot.transform(test_table)
-        imputer = imputer.fit(transormed_table_individual)
-        transormed_table_individual = imputer.transform(transormed_table_individual)
+        transformed_table_individual = one_hot.transform(test_table)
+        imputer = imputer.fit(transformed_table_individual)
+        transformed_table_individual = imputer.transform(transformed_table_individual)
 
-        assert_tables_equal(transfromed_table_sequential, transormed_table_individual)
+        assert_tables_equal(transformed_table_sequential, transformed_table_individual)
 
 
 class TestIsFitted:
-    def test_should_return_false_before_fiting(self) -> None:
+    def test_should_return_false_before_fitting(self) -> None:
         one_hot = OneHotEncoder()
         imputer = SimpleImputer(SimpleImputer.Strategy.constant(0))
         transformers = [one_hot, imputer]
         sequential_table_transformer = SequentialTableTransformer(transformers)
         assert sequential_table_transformer.is_fitted is False
 
-    def test_should_return_true_after_fiting(self) -> None:
+    def test_should_return_true_after_fitting(self) -> None:
         one_hot = OneHotEncoder()
         imputer = SimpleImputer(SimpleImputer.Strategy.constant(0))
         transformers = [one_hot, imputer]