code formatting

Author: yoid2000

syndiffix/microdata.py

@@ -87,7 +87,7 @@ def __init__(self, values: Iterable[Value]) -> None:
         super().__init__()
         # Fit up to 0.9999 so that the max bucket range is [0-1)
         self.scaler = MinMaxScaler(feature_range=(0.0, 0.9999))  # type: ignore
-        # This value-neutral fitting is only for passing unit tests, gets overridden 
+        # This value-neutral fitting is only for passing unit tests, gets overridden
         # later by fit_transform().
         self.scaler.fit(np.array([[0.0], [0.9999]]))
         self.final_round_precision = _get_round_precision(cast(Iterable[float], values))
@@ -119,7 +119,7 @@ def __init__(self) -> None:
         super().__init__()
         # Fit up to 0.9999 so that the max bucket range is [0-1)
         self.scaler = MinMaxScaler(feature_range=(0.0, 0.9999))  # type: ignore
-        # This value-neutral fitting is only for passing unit tests, gets overridden 
+        # This value-neutral fitting is only for passing unit tests, gets overridden
         # later by fit_transform().
         self.scaler.fit(np.array([[0.0], [0.9999]]))
 
@@ -149,7 +149,7 @@ def __init__(self) -> None:
         super().__init__()
         # Fit up to 0.9999 so that the max bucket range is [0-1)
         self.scaler = MinMaxScaler(feature_range=(0.0, 0.9999))  # type: ignore
-        # This value-neutral fitting is only for passing unit tests, gets overridden 
+        # This value-neutral fitting is only for passing unit tests, gets overridden
         # later by fit_transform().
         self.scaler.fit(np.array([[0.0], [0.9999]]))
 
@@ -188,7 +188,7 @@ def __init__(self, values: Iterable[Value]) -> None:
         self.safe_values: Set[float] = set()
         # Fit up to 0.9999 so that the max bucket range is [0-1)
         self.scaler = MinMaxScaler(feature_range=(0.0, 0.9999))  # type: ignore
-        # This value-neutral fitting is only for passing unit tests, gets overridden 
+        # This value-neutral fitting is only for passing unit tests, gets overridden
         # later by fit_transform().
         self.scaler.fit(np.array([[0.0], [0.9999]]))
 
@@ -244,8 +244,8 @@ def analyze_tree_walk(node: Node) -> None:
                     analyze_tree_walk(child_node)
 
         analyze_tree_walk(root)
-        #from .tree import _dump_tree
-        #_dump_tree(root)       # Debugging line to see the tree structure
+        # from .tree import _dump_tree
+        # _dump_tree(root)       # Debugging line to see the tree structure
 
     def denormalize_safe_values(self) -> None:
         assert self.scaler is not None
@@ -360,16 +360,16 @@ def _find_encapsulated_integer_interval(interval: Interval, scaler: MinMaxScaler
     """
     Find the largest interval within the given interval where the inverse-transformed
     bounds correspond to integers (within machine precision).
-    
+
     Args:
         interval: The input interval in normalized space
         scaler: The MinMaxScaler used for inverse transformation
-        
+
     Returns:
         A new interval with bounds that are integer values (cast as floats)
     """
     interval_new = interval.copy()
-    
+
     # Handle singularity case - bounds are already at the same point
     if interval.is_singularity():
         # Convert the single value to its corresponding integer
@@ -378,23 +378,23 @@ def _find_encapsulated_integer_interval(interval: Interval, scaler: MinMaxScaler
         interval_new.min = integer_value
         interval_new.max = integer_value
         return interval_new
-    
+
     # Find the smallest integer >= the inverse-transformed interval.min
     min_inverse = _inverse_normalize_value(interval.min, scaler)
     min_integer = int(round(min_inverse))
-    
+
     # If the current min already transforms to an integer (within precision), use it
     if abs(min_inverse - min_integer) < 1e-10:
         interval_new.min = float(min_integer)
     else:
         # Find the next integer
         next_integer = min_integer + 1 if min_inverse > min_integer else min_integer
         interval_new.min = float(next_integer)
-    
+
     # Find the largest integer <= the inverse-transformed interval.max
     max_inverse = _inverse_normalize_value(interval.max, scaler)
     max_integer = int(round(max_inverse))
-    
+
     # Note that the max value of an Interval is exclusive, so we need to take care
     if abs(max_inverse - max_integer) < 1e-10:
         # If this is exact, then it will be included in the next higher min_integer
@@ -404,13 +404,15 @@ def _find_encapsulated_integer_interval(interval: Interval, scaler: MinMaxScaler
         prev_integer = max_integer - 1 if max_inverse < max_integer else max_integer
         # We add 1.0 because the max value is exclusive
         interval_new.max = float(prev_integer + 1.0)
-    
+
     # Ensure the new interval is valid (min <= max)
     if interval_new.min > interval_new.max:
         # If no valid integer interval exists within bounds, throw an exception
-        raise ValueError(f"No valid integer interval exists within bounds. "
-                        f"Min integer: {interval_new.min}, Max integer: {interval_new.max}")
-    
+        raise ValueError(
+            f"No valid integer interval exists within bounds. "
+            f"Min integer: {interval_new.min}, Max integer: {interval_new.max}"
+        )
+
     return interval_new
 
 
@@ -458,7 +460,7 @@ def apply_convertors(convertors: list[DataConvertor], raw_data: pd.DataFrame) ->
 def generate_microdata(
     buckets: Buckets, convertors: list[DataConvertor], null_mappings: list[float], rng: Random
 ) -> list[MicrodataRow]:
-    #print(buckets)      # Debugging line to see the buckets
+    # print(buckets)      # Debugging line to see the buckets
     [convertor.denormalize_safe_values() for convertor in convertors]
     microdata_rows: list[MicrodataRow] = []
     for bucket in buckets:

syndiffix/tree.py

@@ -280,19 +280,19 @@ def print(self) -> None:
 def _dump_tree(node: Node, indent: int = 0) -> None:
     """Display the tree structure with directory-like indentation."""
     indent_str = "  " * indent
-    
+
     # Format snapped_interval as [(min, max), (min, max), ...]
     intervals_str = ", ".join(f"({interval.min}, {interval.max})" for interval in node.snapped_intervals)
-    
+
     # Get row count
     if isinstance(node, Leaf):
         row_count = len(node.rows)
     else:  # Branch
         row_count = len(list(node._matching_rows()))
-    
+
     # Print this node's info
     print(f"{indent_str}[{intervals_str}] rows: {row_count}")
-    
+
     # Recursively print children if this is a Branch
     if isinstance(node, Branch):
         for child_index in sorted(node.children.keys()):

tests/test_synthesizer.py

@@ -177,12 +177,12 @@ def test_normalize_strings() -> None:
 
 def test_string_consistency() -> None:
     # Create a dataframe with identical values in both columns
-    c1_values = ['a'] * 10 + ['b'] * 10 + ['c'] * 10
+    c1_values = ["a"] * 10 + ["b"] * 10 + ["c"] * 10
     c2_values = c1_values.copy()  # c2 is identical to c1
     df = pd.DataFrame({"c1": c1_values, "c2": c2_values})
-    
+
     syn_data = Synthesizer(df).sample()
-    
+
     # Ensure all values for c1 and c2 match in the synthetic dataframe
     for i in range(len(syn_data)):
         c1_val = syn_data.iloc[i, 0]  # First column (c1)
@@ -267,42 +267,42 @@ def test_value_safe_columns_strings() -> None:
 
 def test_pid() -> None:
     np.random.seed(42)  # For reproducible tests
-    
+
     # Create 20 distinct strings: 10 starting with 'a', 10 starting with 'b'
     strings_c1 = []
     for i in range(10):
         # Generate 4 random characters for the suffix
-        suffix = ''.join(np.random.choice(list('abcdefghijklmnopqrstuvwxyz'), 4))
-        strings_c1.append(f'a{suffix}')
-    
+        suffix = "".join(np.random.choice(list("abcdefghijklmnopqrstuvwxyz"), 4))
+        strings_c1.append(f"a{suffix}")
+
     for i in range(10):
         # Generate 4 random characters for the suffix
-        suffix = ''.join(np.random.choice(list('abcdefghijklmnopqrstuvwxyz'), 4))
-        strings_c1.append(f'b{suffix}')
-    
+        suffix = "".join(np.random.choice(list("abcdefghijklmnopqrstuvwxyz"), 4))
+        strings_c1.append(f"b{suffix}")
+
     # Create 20 distinct PIDs (integers)
     pids = list(range(20))
-    
+
     # Create mapping from string to PID
     string_to_pid = dict(zip(strings_c1, pids))
-    
+
     # Generate 1000 rows with random string selections and corresponding PIDs
     selected_strings = np.random.choice(strings_c1, 1000)
     selected_pids = [string_to_pid[s] for s in selected_strings]
-    
+
     # Create the dataframe
     df = pd.DataFrame({"pid": selected_pids, "c1": selected_strings})
-    
+
     # Build synthetic dataframe using PID functionality
     df_pid = df[["pid"]]
     df_without_pid = df.drop(columns=["pid"])
     syn_data = Synthesizer(df_without_pid, pids=df_pid).sample()
-    
+
     # Check that none of the values in syn_data['c1'] match any of the values in df_without_pid['c1']
-    original_c1_values = set(df_without_pid['c1'])
-    synthetic_c1_values = set(syn_data['c1'])
+    original_c1_values = set(df_without_pid["c1"])
+    synthetic_c1_values = set(syn_data["c1"])
     assert synthetic_c1_values.isdisjoint(original_c1_values), "Synthetic values should not match original values"
-    
+
     # 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'"
+    for value in syn_data["c1"]:
+        assert value.startswith("a") or value.startswith("b"), f"Value '{value}' does not start with 'a' or 'b'"