feat: Maintain tagging in methods inherited from Table class

src/safeds/exceptions/__init__.py

@@ -1,9 +1,11 @@
 """Custom exceptions that can be raised by Safe-DS."""
 
 from safeds.exceptions._data import (
+    ColumnIsTaggedError,
     ColumnLengthMismatchError,
     ColumnSizeError,
     DuplicateColumnNameError,
+    IllegalSchemaModificationError,
     IndexOutOfBoundsError,
     NonNumericColumnError,
     SchemaMismatchError,
@@ -33,6 +35,8 @@
     "UnknownColumnNameError",
     "ValueNotPresentWhenFittedError",
     "WrongFileExtensionError",
+    "IllegalSchemaModificationError",
+    "ColumnIsTaggedError",
     # ML exceptions
     "DatasetContainsTargetError",
     "DatasetMissesFeaturesError",

src/safeds/exceptions/_data.py

@@ -112,3 +112,17 @@ def __init__(self, file: str | Path, file_extension: str | list[str]) -> None:
                 f" {file_extension}"
             ),
         )
+
+
+class IllegalSchemaModificationError(Exception):
+    """Exception raised when modifying the schema in a way that is not consistent with the subclass's requirements."""
+
+    def __init__(self, msg: str) -> None:
+        super().__init__(f"Illegal schema modification: {msg}")
+
+
+class ColumnIsTaggedError(IllegalSchemaModificationError):
+    """Exception raised in overriden methods of the Table class when removing tagged Columns from a TaggedTable."""
+
+    def __init__(self, column_name: str) -> None:
+        super().__init__(f'Column "{column_name}" is tagged and cannot be removed.')

tests/safeds/data/tabular/containers/_table/_tagged_table/test_add_column.py

@@ -0,0 +1,27 @@
+from safeds.data.tabular.containers import Column, TaggedTable
+
+
+def test_should_add_column() -> None:
+    table = TaggedTable(
+        {
+            "feature_1": [0, 1, 2],
+            "target": [3, 4, 5],
+        },
+        "target",
+        None,
+    )
+    col = Column("feature_2", [6, 7, 8])
+    new_table = table.add_column(col)
+    expected = TaggedTable(
+        {
+            "feature_1": [0, 1, 2],
+            "target": [3, 4, 5],
+            "feature_2": [6, 7, 8],
+        },
+        "target",
+        None,
+    )
+    assert new_table.schema == expected.schema
+    assert new_table.features == expected.features
+    assert new_table.target == expected.target
+    assert new_table == expected

tests/safeds/data/tabular/containers/_table/_tagged_table/test_add_columns.py

@@ -0,0 +1,31 @@
+from safeds.data.tabular.containers import Column, TaggedTable
+
+
+def test_should_add_columns() -> None:
+    table = TaggedTable(
+        {
+            "feature_1": [0, 1, 2],
+            "target": [3, 4, 5],
+        },
+        "target",
+        None,
+    )
+    cols = [
+        Column("feature_2", [6, 7, 8]),
+        Column("feature_3", [9, 6, 3]),
+    ]
+    new_table = table.add_columns(cols)
+    expected = TaggedTable(
+        {
+            "feature_1": [0, 1, 2],
+            "target": [3, 4, 5],
+            "feature_2": [6, 7, 8],
+            "feature_3": [9, 6, 3],
+        },
+        "target",
+        None,
+    )
+    assert new_table.schema == expected.schema
+    assert new_table.features == expected.features
+    assert new_table.target == expected.target
+    assert new_table == expected

tests/safeds/data/tabular/containers/_table/_tagged_table/test_add_row.py

@@ -0,0 +1,31 @@
+from safeds.data.tabular.containers import Row, TaggedTable
+
+
+def test_should_add_row() -> None:
+    table = TaggedTable(
+        {
+            "feature": [0, 1],
+            "target": [3, 4],
+        },
+        "target",
+        None,
+    )
+    row = Row(
+        {
+            "feature": 2,
+            "target": 5,
+        },
+    )
+    new_table = table.add_row(row)
+    expected = TaggedTable(
+        {
+            "feature": [0, 1, 2],
+            "target": [3, 4, 5],
+        },
+        "target",
+        None,
+    )
+    assert new_table.schema == expected.schema
+    assert new_table.features == expected.features
+    assert new_table.target == expected.target
+    assert new_table == expected

tests/safeds/data/tabular/containers/_table/_tagged_table/test_add_rows.py

@@ -0,0 +1,34 @@
+from safeds.data.tabular.containers import Row, TaggedTable
+
+
+def test_should_add_rows() -> None:
+    table = TaggedTable(
+        {
+            "feature": [0, 1],
+            "target": [4, 5],
+        },
+        "target",
+        None,
+    )
+    rows = [
+        Row(
+            {
+                "feature": 2,
+                "target": 6,
+            },
+        ),
+        Row({"feature": 3, "target": 7}),
+    ]
+    new_table = table.add_rows(rows)
+    expected = TaggedTable(
+        {
+            "feature": [0, 1, 2, 3],
+            "target": [4, 5, 6, 7],
+        },
+        "target",
+        None,
+    )
+    assert new_table.schema == expected.schema
+    assert new_table.features == expected.features
+    assert new_table.target == expected.target
+    assert new_table == expected

tests/safeds/data/tabular/containers/_table/_tagged_table/test_filter_rows.py

@@ -0,0 +1,27 @@
+from safeds.data.tabular.containers import TaggedTable
+
+
+def test_should_remove_row() -> None:
+    table = TaggedTable(
+        {
+            "feature_1": [3, 9, 6],
+            "feature_2": [6, 12, 9],
+            "target": [1, 3, 2],
+        },
+        "target",
+        None,
+    )
+    new_table = table.filter_rows(lambda row: all(row.get_value(col) < 10 for col in table.column_names))
+    expected = TaggedTable(
+        {
+            "feature_1": [3, 6],
+            "feature_2": [6, 9],
+            "target": [1, 2],
+        },
+        "target",
+        None,
+    )
+    assert new_table.schema == expected.schema
+    assert new_table.features == expected.features
+    assert new_table.target == expected.target
+    assert new_table == expected

tests/safeds/data/tabular/containers/_table/_tagged_table/test_remove_columns_with_missing_values.py

@@ -0,0 +1,44 @@
+import pytest
+from safeds.data.tabular.containers import TaggedTable
+from safeds.exceptions import ColumnIsTaggedError
+
+
+def test_should_remove_column() -> None:
+    table = TaggedTable(
+        {
+            "feature_complete": [0, 1, 2],
+            "feature_incomplete": [3, None, 5],
+            "target": [6, 7, 8],
+        },
+        "target",
+        None,
+    )
+    new_table = table.remove_columns_with_missing_values()
+    expected = TaggedTable(
+        {
+            "feature_complete": [0, 1, 2],
+            "target": [6, 7, 8],
+        },
+        "target",
+        None,
+    )
+    assert new_table.schema == expected.schema
+    assert new_table.features == expected.features
+    assert new_table.target == expected.target
+    assert new_table == expected
+
+
+def test_should_throw_column_is_tagged() -> None:
+    table = TaggedTable(
+        {
+            "feature": [0, 1, 2],
+            "target": [3, None, 5],
+        },
+        "target",
+        None,
+    )
+    with pytest.raises(
+        ColumnIsTaggedError,
+        match='Illegal schema modification: Column "target" is tagged and cannot be removed.',
+    ):
+        table.remove_columns_with_missing_values()

tests/safeds/data/tabular/containers/_table/_tagged_table/test_remove_columns_with_non_numerical_values.py

@@ -0,0 +1,44 @@
+import pytest
+from safeds.data.tabular.containers import TaggedTable
+from safeds.exceptions import ColumnIsTaggedError
+
+
+def test_should_remove_column() -> None:
+    table = TaggedTable(
+        {
+            "feature_numerical": [0, 1, 2],
+            "feature_non_numerical": ["a", "b", "c"],
+            "target": [3, 4, 5],
+        },
+        "target",
+        None,
+    )
+    new_table = table.remove_columns_with_non_numerical_values()
+    expected = TaggedTable(
+        {
+            "feature_numerical": [0, 1, 2],
+            "target": [3, 4, 5],
+        },
+        "target",
+        None,
+    )
+    assert new_table.schema == expected.schema
+    assert new_table.features == expected.features
+    assert new_table.target == expected.target
+    assert new_table == expected
+
+
+def test_should_throw_column_is_tagged() -> None:
+    table = TaggedTable(
+        {
+            "feature": [0, 1, 2],
+            "target": ["a", "b", "c"],
+        },
+        "target",
+        None,
+    )
+    with pytest.raises(
+        ColumnIsTaggedError,
+        match='Illegal schema modification: Column "target" is tagged and cannot be removed.',
+    ):
+        table.remove_columns_with_non_numerical_values()

tests/safeds/data/tabular/containers/_table/_tagged_table/test_remove_duplicate_rows.py

@@ -0,0 +1,25 @@
+from safeds.data.tabular.containers import TaggedTable
+
+
+def test_should_remove_row() -> None:
+    table = TaggedTable(
+        {
+            "feature": [0, 0, 1],
+            "target": [2, 2, 3],
+        },
+        "target",
+        None,
+    )
+    new_table = table.remove_duplicate_rows()
+    expected = TaggedTable(
+        {
+            "feature": [0, 1],
+            "target": [2, 3],
+        },
+        "target",
+        None,
+    )
+    assert new_table.schema == expected.schema
+    assert new_table.features == expected.features
+    assert new_table.target == expected.target
+    assert new_table == expected

tests/safeds/data/tabular/containers/_table/_tagged_table/test_remove_rows_with_missing_values.py

@@ -0,0 +1,25 @@
+from safeds.data.tabular.containers import TaggedTable
+
+
+def test_should_remove_row() -> None:
+    table = TaggedTable(
+        {
+            "feature": [0.0, None, 2.0],
+            "target": [3.0, 4.0, 5.0],
+        },
+        "target",
+        None,
+    )
+    new_table = table.remove_rows_with_missing_values()
+    expected = TaggedTable(
+        {
+            "feature": [0.0, 2.0],
+            "target": [3.0, 5.0],
+        },
+        "target",
+        None,
+    )
+    assert new_table.schema == expected.schema
+    assert new_table.features == expected.features
+    assert new_table.target == expected.target
+    assert new_table == expected

tests/safeds/data/tabular/containers/_table/_tagged_table/test_remove_rows_with_outliers.py

@@ -0,0 +1,25 @@
+from safeds.data.tabular.containers import TaggedTable
+
+
+def test_should_remove_row() -> None:
+    table = TaggedTable(
+        {
+            "feature": [1.0, 11.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0],
+            "target": [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0],
+        },
+        "target",
+        None,
+    )
+    new_table = table.remove_rows_with_outliers()
+    expected = TaggedTable(
+        {
+            "feature": [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0],
+            "target": [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0],
+        },
+        "target",
+        None,
+    )
+    assert new_table.schema == expected.schema
+    assert new_table.features == expected.features
+    assert new_table.target == expected.target
+    assert new_table == expected