make release-tag: Merge branch 'main' into stable

Author: rwedge

HISTORY.md

@@ -1,5 +1,12 @@
 # Release Notes
 
+## v1.29.1 - 2025-11-21
+
+### Bugs Fixed
+
+* Warning raised multiple times when metadata does not have the 'datetime_format' key - Issue [#2739](https://github.com/sdv-dev/SDV/issues/2739) by @fealho
+* Adding constraints to multi-table synthesizer in multiple steps causes fit to crash - Issue [#2736](https://github.com/sdv-dev/SDV/issues/2736) by @frances-h
+
 ## v1.29.0 - 2025-11-14
 
 ### New Features

latest_requirements.txt

@@ -3,7 +3,7 @@ copulas==0.12.3
 ctgan==0.11.1
 deepecho==0.7.0
 graphviz==0.21
-numpy==2.3.4
+numpy==2.3.5
 pandas==2.3.3
 platformdirs==4.5.0
 rdt==1.18.2

pyproject.toml

@@ -142,7 +142,7 @@ namespaces = false
 version = {attr = 'sdv.__version__'}
 
 [tool.bumpversion]
-current_version = "1.29.0"
+current_version = "1.29.1.dev1"
 parse = '(?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)(\.(?P<release>[a-z]+)(?P<candidate>\d+))?'
 serialize = [
     '{major}.{minor}.{patch}.{release}{candidate}',

sdv/__init__.py

@@ -6,7 +6,7 @@
 
 __author__ = 'DataCebo, Inc.'
 __email__ = '[email protected]'
-__version__ = '1.29.0'
+__version__ = '1.29.1.dev1'
 
 
 import sys

sdv/metadata/single_table.py

@@ -1296,6 +1296,7 @@ def validate_data(self, data, sdtype_warnings=None):
             A warning is being raised if ``datetime_format`` is missing from a column represented
             as ``object`` in the dataframe and its sdtype is ``datetime``.
         """
+        _datetime_format_warning_flag = sdtype_warnings is not None
         sdtype_warnings = sdtype_warnings if sdtype_warnings is not None else defaultdict(list)
         if not isinstance(data, pd.DataFrame):
             raise ValueError(f'Data must be a DataFrame, not a {type(data)}.')
@@ -1315,7 +1316,7 @@ def validate_data(self, data, sdtype_warnings=None):
             errors += self._validate_column_data(data[column], sdtype_warnings)
 
         errors += self._validate_primary_key(data)
-        if sdtype_warnings is not None and len(sdtype_warnings):
+        if (not _datetime_format_warning_flag) and len(sdtype_warnings):
             df = pd.DataFrame(sdtype_warnings)
             message = (
                 "No 'datetime_format' is present in the metadata for the following columns:\n"

sdv/multi_table/base.py

@@ -82,14 +82,17 @@ def _set_temp_numpy_seed(self):
 
     def _initialize_models(self):
         with disable_single_table_logger():
-            for table_name, table_metadata in self.metadata.tables.items():
+            for table_name, table_metadata in self._modified_multi_table_metadata.tables.items():
                 synthesizer_parameters = {'locales': self.locales}
                 synthesizer_parameters.update(self._table_parameters.get(table_name, {}))
                 metadata_dict = {'tables': {table_name: table_metadata.to_dict()}}
                 metadata = Metadata.load_from_dict(metadata_dict)
                 self._table_synthesizers[table_name] = self._synthesizer(
                     metadata=metadata, **synthesizer_parameters
                 )
+                # Mark synthesizer as embedded in a multi-table setting
+                # so it can suppres datetime_format warnings that are aggregated here
+                self._table_synthesizers[table_name]._suppress_datetime_format_warning = True
                 self._table_synthesizers[table_name]._data_processor.table_name = table_name
 
     def _get_pbar_args(self, **kwargs):
@@ -129,7 +132,7 @@ def __init__(self, metadata, locales=['en_US'], synthesizer_kwargs=None):
         self._original_metadata = deepcopy(self.metadata)
         self._modified_multi_table_metadata = deepcopy(self.metadata)
         self.constraints = []
-        self._has_seen_single_table_constraint = False
+        self._single_table_constraints = []
         if synthesizer_kwargs is not None:
             warn_message = (
                 'The `synthesizer_kwargs` parameter is deprecated as of SDV 1.2.0 and does not '
@@ -177,9 +180,10 @@ def _detect_single_table_constraints(self, constraints):
             constraints (list):
                 A list of constraints to filter.
         """
-        idx_single_table_constraint = 0 if self._has_seen_single_table_constraint else None
+        has_seen_single_table_constraint = len(self._single_table_constraints) > 0
+        idx_single_table_constraint = 0 if has_seen_single_table_constraint else None
         for idx, constraint in enumerate(constraints):
-            if self._has_seen_single_table_constraint and constraint._is_single_table is False:
+            if has_seen_single_table_constraint and constraint._is_single_table is False:
                 raise SynthesizerInputError(
                     'Cannot apply multi-table constraint after single-table constraint has '
                     'been applied.'
@@ -188,8 +192,8 @@ def _detect_single_table_constraints(self, constraints):
             if not constraint._is_single_table:
                 continue
 
-            if not self._has_seen_single_table_constraint:
-                self._has_seen_single_table_constraint = True
+            if not has_seen_single_table_constraint:
+                has_seen_single_table_constraint = True
                 idx_single_table_constraint = idx
 
         return idx_single_table_constraint
@@ -231,20 +235,21 @@ def add_constraints(self, constraints):
         self.constraints += multi_table_constraints
         self._constraints_fitted = False
         self._initialize_models()
-        if single_table_constraints:
-            for constraint in single_table_constraints:
+        if self._single_table_constraints or single_table_constraints:
+            for constraint in [*self._single_table_constraints, *single_table_constraints]:
                 table_name = constraint.table_name
                 self._table_synthesizers[table_name].add_constraints([constraint])
                 try:
                     self.metadata = constraint.get_updated_metadata(self.metadata)
                 except ConstraintNotMetError:
                     constraint.get_updated_metadata(self._modified_multi_table_metadata)
 
+        self._single_table_constraints += single_table_constraints
+
     def get_constraints(self):
         """Get a copy of the list of constraints applied to the synthesizer."""
         if not hasattr(self, 'constraints'):
             return []
-
         constraints = []
         for constraint in self.constraints:
             if isinstance(constraint, ProgrammableConstraintHarness):
@@ -404,6 +409,8 @@ def set_table_parameters(self, table_name, table_parameters):
         self._table_synthesizers[table_name] = self._synthesizer(
             metadata=table_metadata, **table_parameters
         )
+        # Mark synthesizer as embedded in a multi-table setting to avoid duplicate datetime warnings
+        self._table_synthesizers[table_name]._suppress_datetime_format_warning = True
         self._table_synthesizers[table_name]._data_processor.table_name = table_name
         self._table_parameters[table_name].update(deepcopy(table_parameters))
 

sdv/single_table/base.py

@@ -561,7 +561,18 @@ def validate(self, data):
             data (pandas.DataFrame):
                 The data to validate.
         """
-        self._original_metadata.validate_data({self._table_name: data})
+        # Suppress duplicate datetime_format warning only when this single-table synthesizer
+        # is embedded inside a multi-table synthesizer
+        if getattr(self, '_suppress_datetime_format_warning', False):
+            with warnings.catch_warnings():
+                warnings.filterwarnings(
+                    'ignore',
+                    message=r"No 'datetime_format' is present.*",
+                    category=UserWarning,
+                )
+                self._original_metadata.validate_data({self._table_name: data})
+        else:
+            self._original_metadata.validate_data({self._table_name: data})
         self._validate_transform_constraints(data, enforce_constraint_fitting=True)
 
         # Retaining the logic of returning errors and raising them here to maintain consistency

sdv/utils/utils.py

@@ -2,6 +2,7 @@
 
 import datetime
 import sys
+import warnings
 from copy import deepcopy
 
 import cloudpickle
@@ -55,7 +56,14 @@ def drop_unknown_references(data, metadata, drop_missing_values=False, verbose=T
     })
     metadata.validate()
     try:
-        metadata.validate_data(data)
+        # Suppress duplicate datetime_format warnings during referential integrity validation.
+        with warnings.catch_warnings():
+            warnings.filterwarnings(
+                'ignore',
+                message=r"No 'datetime_format' is present.*",
+                category=UserWarning,
+            )
+            metadata.validate_data(data)
         if drop_missing_values:
             _validate_foreign_keys_not_null(metadata, data)
 

static_code_analysis.txt

@@ -1,4 +1,4 @@
-Run started:2025-11-14 21:11:19.372743
+Run started:2025-11-21 21:03:20.369781
 
 Test results:
 >> Issue: [B110:try_except_pass] Try, Except, Pass detected.
@@ -121,7 +121,7 @@ Test results:
 --------------------------------------------------
 
 Code scanned:
-	Total lines of code: 17119
+	Total lines of code: 17140
 	Total lines skipped (#nosec): 0
 	Total potential issues skipped due to specifically being disabled (e.g., #nosec BXXX): 0
 

tests/integration/multi_table/test_constraints.py

@@ -47,3 +47,47 @@ def test_overlapping_single_table_constraints():
     # Assert
     assert all(sampled['parent_table']['colA'] < sampled['parent_table']['colB'])
     assert all(sampled['parent_table']['colB'] < sampled['parent_table']['colC'])
+
+
+def test_add_constraint_iteratively():
+    """Test adding constraints in multiple steps."""
+    # Setup
+    parent_table = pd.DataFrame({
+        'id': [i for i in range(20)],
+        'colA': np.random.randint(low=0, high=100, size=20),
+    })
+    parent_table['colB'] = parent_table['colA'] + np.random.randint(low=1, high=10, size=20)
+    parent_table['colC'] = parent_table['colB'] + np.random.randint(low=1, high=10, size=20)
+
+    child_table = pd.DataFrame({
+        'parent_id': np.random.randint(low=0, high=20, size=100),
+        'colD': np.random.randint(low=100, high=200, size=100),
+    })
+    data = {'parent_table': parent_table, 'child_table': child_table}
+
+    metadata = Metadata()
+    metadata = Metadata.detect_from_dataframes(data)
+
+    constraint1 = Inequality(
+        low_column_name='colA',
+        high_column_name='colB',
+        table_name='parent_table',
+        strict_boundaries=True,
+    )
+    constraint2 = Inequality(
+        low_column_name='colB',
+        high_column_name='colC',
+        table_name='parent_table',
+        strict_boundaries=True,
+    )
+    synthesizer = HMASynthesizer(metadata)
+
+    # Run
+    synthesizer.add_constraints([constraint1])
+    synthesizer.add_constraints([constraint2])
+    synthesizer.fit(data)
+    sampled = synthesizer.sample(10)
+
+    # Assert
+    assert all(sampled['parent_table']['colA'] < sampled['parent_table']['colB'])
+    assert all(sampled['parent_table']['colB'] < sampled['parent_table']['colC'])