done and tested

Author: yoid2000

docs/development.md

@@ -11,7 +11,7 @@ Activate `poetry` environment: `poetry shell`. (can skip, then prepend `poetry r
 - Check: `flake8 . && mypy . && black --check . && isort . --check`
 
  To filter out acceptable lines:
-     `poetry run flake8 . | findstr /v "E501" | findstr /v "F405" | findstr /v "F403"`
+     `poetry run flake8 syndiffix | findstr /v "E501" | findstr /v "F405" | findstr /v "F403"`
 
 ### Creating a new release
 

syndiffix/clustering/common.py

@@ -34,7 +34,7 @@ class Clusters:
     derived_clusters: list[DerivedCluster]
 
 
-TreeMaterializer = Callable[[Forest, list[ColumnId]], tuple[list[MicrodataRow], Combination]]
+TreeBuilder = Callable[[Forest, list[ColumnId]], None]
 
 TableMaterializer = Callable[[Forest, list[ColumnId]], tuple[list[MicrodataRow], Combination]]
 

syndiffix/clustering/stitching.py

@@ -376,6 +376,13 @@ def _stitch(
         return _do_stitch(forest, metadata, left, right, derived_cluster)
 
 
+def build_forest(tree_builder: TreeBuilder, forest: Forest, clusters: Clusters) -> None:
+    tree_builder(forest, clusters.initial_cluster)
+    for derived_cluster in clusters.derived_clusters:
+        (_, stitch_columns, derived_columns) = derived_cluster
+        tree_builder(forest, stitch_columns + derived_columns)
+
+
 def build_table(
     materialize_table: TableMaterializer, forest: Forest, metadata: StitchingMetadata, clusters: Clusters
 ) -> tuple[list[Row], Combination]:

syndiffix/synthesizer.py

@@ -9,7 +9,7 @@
 
 from .bucket import harvest
 from .clustering.common import MicrodataRow
-from .clustering.stitching import StitchingMetadata, build_table
+from .clustering.stitching import StitchingMetadata, build_forest, build_table
 from .clustering.strategy import ClusteringStrategy, DefaultClustering, MlClustering
 from .common import *
 from .counters import (
@@ -118,6 +118,17 @@ def __init__(
         for col_id, converter in enumerate(self.column_convertors):
             converter.analyze_tree(self.forest.get_tree((ColumnId(col_id),)))
 
+        def tree_builder(forest: Forest, columns: list[ColumnId]) -> None:
+            combination = tuple(sorted(columns))
+            # get_tree builds the trees (except 1dim, which have already been built)
+            _ = forest.get_tree(combination)
+
+        build_forest(
+            tree_builder,
+            self.forest,
+            self.clusters,
+        )
+
     def sample(self) -> pd.DataFrame:
         def materialize_table(forest: Forest, columns: list[ColumnId]) -> tuple[list[MicrodataRow], Combination]:
             combination = tuple(sorted(columns))

tests/test_synthesizer.py

@@ -306,3 +306,32 @@ def test_pid() -> None:
     # Check that every value in syn_data['c1'] begins with either 'a' or 'b'
     for value in syn_data["c1"]:
         assert value.startswith("a") or value.startswith("b"), f"Value '{value}' does not start with 'a' or 'b'"
+
+
+def test_tree_builder() -> None:
+    # Create a dataframe with three columns
+    np.random.seed(42)  # For reproducible tests
+    df = pd.DataFrame(
+        {
+            "col1": np.random.choice(["A", "B", "C"], size=100),
+            "col2": np.random.randint(0, 10, size=100),
+            "col3": np.random.uniform(0, 1, size=100),
+        }
+    )
+
+    # Create synthesizer (this should build all trees)
+    syn = Synthesizer(df)
+
+    # Import necessary types for combinations
+    from itertools import combinations
+
+    from syndiffix.common import ColumnId
+
+    # Test all possible combinations of columns (1, 2, and 3 columns)
+    column_indices = [ColumnId(0), ColumnId(1), ColumnId(2)]  # Indices for col1, col2, col3
+
+    for r in range(1, 4):  # 1, 2, and 3 columns
+        for combination in combinations(column_indices, r):
+            # Convert to tuple as expected by the tree cache
+            tree = syn.forest._tree_cache.get(combination)
+            assert tree is not None, f"Tree not found for combination {combination}"