Merge branch 'main' into feature-branch-download-demo

Author: fealho

sdv/_utils.py

@@ -273,7 +273,7 @@ def check_sdv_versions_and_warn(synthesizer):
     """
     current_community_version = getattr(version, 'community', None)
     current_enterprise_version = getattr(version, 'enterprise', None)
-    if synthesizer._fitted:
+    if getattr(synthesizer, '_fitted', False):
         fitted_community_version = getattr(synthesizer, '_fitted_sdv_version', None)
         fitted_enterprise_version = getattr(synthesizer, '_fitted_sdv_enterprise_version', None)
         community_mismatch = current_community_version != fitted_community_version

sdv/multi_table/_dayz_utils.py

@@ -34,8 +34,8 @@ def detect_relationship_parameters(data, metadata):
             'child_table_name': rel_tuple[1],
             'parent_primary_key': rel_tuple[2],
             'child_foreign_key': rel_tuple[3],
-            'min_cardinality': cardinality_table['cardinality'].min(),
-            'max_cardinality': cardinality_table['cardinality'].max(),
+            'min_cardinality': int(cardinality_table['cardinality'].min()),
+            'max_cardinality': int(cardinality_table['cardinality'].max()),
         })
 
     return relationship_parameters

sdv/multi_table/dayz.py

@@ -1,5 +1,6 @@
 """Multi-Table DayZ parameter detection and creation."""
 
+from sdv.cag._utils import _is_list_of_type
 from sdv.errors import SynthesizerInputError, SynthesizerProcessingError
 from sdv.multi_table._dayz_utils import create_parameters_multi_table
 from sdv.single_table.dayz import _validate_parameter_structure, _validate_tables_parameter
@@ -48,8 +49,10 @@ def _validate_cardinality_bounds(relationship):
 
 
 def _validate_relationship_structure(dayz_parameters):
-    if not isinstance(dayz_parameters.get('relationships', []), list):
-        raise SynthesizerProcessingError("The 'relationships' parameter value must be a list.")
+    if not _is_list_of_type(dayz_parameters.get('relationships', []), dict):
+        raise SynthesizerProcessingError(
+            "The 'relationships' parameter value must be a list of dictionaries."
+        )
 
     for relationship in dayz_parameters.get('relationships', []):
         unknown_relationship_parameters = relationship.keys() - set(RELATIONSHIP_PARAMETER_KEYS)
@@ -160,18 +163,18 @@ def __init__(self, metadata, locales=['en_US']):
         )
 
     @classmethod
-    def create_parameters(cls, data, metadata, output_filename=None):
+    def create_parameters(cls, data, metadata, filepath=None):
         """Create parameters for the DayZSynthesizer.
 
         Args:
             data (dict[str, pd.DataFrame]): The input data.
             metadata (Metadata): The metadata object.
-            output_filename (str, optional): The output filename for the parameters.
+            filepath (str, optional): The output filename for the parameters.
 
         Returns:
             dict: The created parameters.
         """
-        return create_parameters_multi_table(data, metadata, output_filename)
+        return create_parameters_multi_table(data, metadata, filepath)
 
     @staticmethod
     def validate_parameters(metadata, parameters):

sdv/single_table/_dayz_utils.py

@@ -18,6 +18,79 @@ def detect_table_parameters(data):
     return {'num_rows': len(data)}
 
 
+def _compute_missing_values_proportion(series):
+    """Compute missing value proportion with a safe fallback for empty series."""
+    if len(series) == 0:
+        return 0.0
+
+    value = float(series.isna().mean())
+    return 0.0 if pd.isna(value) else value
+
+
+def _detect_numerical_column_parameters(series):
+    """Detect numerical-specific parameters with fallbacks when undetectable.
+
+    Returns only keys that can be reliably detected (no None values).
+    """
+    params = {}
+    non_null = series.dropna()
+    if non_null.empty:
+        return params
+
+    try:
+        num_decimal_digits = learn_rounding_digits(series)
+        if isinstance(num_decimal_digits, int) and num_decimal_digits >= 0:
+            params['num_decimal_digits'] = num_decimal_digits
+    except Exception:
+        pass
+
+    min_value = non_null.min()
+    max_value = non_null.max()
+    if not pd.isna(min_value):
+        params['min_value'] = min_value.item() if hasattr(min_value, 'item') else float(min_value)
+    if not pd.isna(max_value):
+        params['max_value'] = max_value.item() if hasattr(max_value, 'item') else float(max_value)
+
+    return params
+
+
+def _detect_datetime_column_parameters(series, column_metadata):
+    """Detect datetime-specific parameters with fallbacks when undetectable.
+
+    Returns only keys that can be reliably detected (no None values).
+    """
+    params = {}
+    datetime_format = column_metadata.get('datetime_format', None)
+    if datetime_format:
+        datetime_column = pd.to_datetime(series, format=datetime_format, errors='coerce')
+    else:
+        datetime_column = pd.to_datetime(series, errors='coerce')
+
+    non_na = datetime_column[~pd.isna(datetime_column)]
+    if non_na.empty:
+        return params
+
+    start_dt = non_na.min()
+    end_dt = non_na.max()
+    if datetime_format:
+        params['start_timestamp'] = start_dt.strftime(datetime_format)
+        params['end_timestamp'] = end_dt.strftime(datetime_format)
+    else:
+        params['start_timestamp'] = start_dt.strftime('%Y-%m-%d %H:%M:%S')
+        params['end_timestamp'] = end_dt.strftime('%Y-%m-%d %H:%M:%S')
+
+    return params
+
+
+def _detect_categorical_column_parameters(series):
+    """Detect categorical/boolean parameters."""
+    categorical_values = series.dropna().unique()
+    if len(categorical_values) == 0:
+        return {}
+
+    return {'category_values': categorical_values.tolist()}
+
+
 def detect_column_parameters(data, metadata, table_name):
     """Detect all column-level Dayz parameters.
 
@@ -37,46 +110,28 @@ def detect_column_parameters(data, metadata, table_name):
     table_metadata = metadata.tables[table_name]
     column_parameters = {}
     for column_name, column_metadata in table_metadata.columns.items():
-        column_parameters[column_name] = {}
         sdtype = column_metadata['sdtype']
+        params = {}
         if sdtype == 'numerical':
-            column_parameters[column_name] = {
-                'num_decimal_digits': learn_rounding_digits(data[column_name]),
-                'min_value': data[column_name].min(),
-                'max_value': data[column_name].max(),
-            }
+            params.update(_detect_numerical_column_parameters(data[column_name]))
         elif sdtype == 'datetime':
-            datetime_format = column_metadata.get('datetime_format', None)
-            if datetime_format:
-                datetime_column = pd.to_datetime(
-                    data[column_name], format=datetime_format, errors='coerce'
-                )
-                start_timestamp = datetime_column.min().strftime(datetime_format)
-                end_timestamp = datetime_column.max().strftime(datetime_format)
-
-            else:
-                datetime_column = pd.to_datetime(data[column_name], errors='coerce')
-                start_timestamp = str(datetime_column.min())
-                end_timestamp = str(datetime_column.max())
-
-            column_parameters[column_name] = {
-                'start_timestamp': start_timestamp,
-                'end_timestamp': end_timestamp,
-            }
+            params.update(_detect_datetime_column_parameters(data[column_name], column_metadata))
         elif sdtype == 'categorical':
-            column_parameters[column_name] = {
-                'category_values': data[column_name].dropna().unique().tolist()
-            }
+            params.update(_detect_categorical_column_parameters(data[column_name]))
 
-        column_parameters[column_name]['missing_values_proportion'] = float(
-            data[column_name].isna().mean()
-        )
+        params['missing_values_proportion'] = _compute_missing_values_proportion(data[column_name])
+        column_parameters[column_name] = params
 
     return {'columns': column_parameters}
 
 
 def create_parameters(data, metadata, output_filename):
     """Detect and create a parameter dict for the DayZ model."""
+    if len(data) == 0:
+        raise ValueError('Data is empty')
+    if len(metadata.tables) == 0:
+        raise ValueError('Metadata is empty')
+
     metadata.validate()
     datas = data if isinstance(data, dict) else {metadata._get_single_table_name(): data}
     metadata.validate_data(datas)

sdv/single_table/dayz.py

@@ -227,6 +227,13 @@ def _validate_parameters(metadata, parameters):
     """
     metadata.validate()
     _validate_parameter_structure(parameters)
+
+    if len(metadata.tables) > 1:
+        raise SynthesizerProcessingError(
+            'Invalid metadata provided for single-table DayZSynthesizer. The metadata contains '
+            'multiple tables. Please use multi-table DayZSynthesizer instead.'
+        )
+
     if 'relationships' in parameters:
         msg = (
             "Invalid DayZ parameter 'relationships' for single-table DayZSynthesizer. "
@@ -248,18 +255,18 @@ def __init__(self, metadata, locales=['en_US']):
         )
 
     @classmethod
-    def create_parameters(cls, data, metadata, output_filename=None):
+    def create_parameters(cls, data, metadata, filepath=None):
         """Create parameters for the DayZ synthesizer.
 
         Args:
             data (pd.DataFrame): The input data.
             metadata (Metadata): The metadata object.
-            output_filename (str, optional): The output filename for the parameters.
+            filepath (str, optional): The output filename for the parameters.
 
         Returns:
             dict: The created parameters.
         """
-        return create_parameters(data, metadata, output_filename)
+        return create_parameters(data, metadata, filepath)
 
     @staticmethod
     def validate_parameters(metadata, parameters):

tests/integration/multi_table/test_dayz.py

@@ -1,5 +1,8 @@
 """Integration tests for DayZ parameter detection."""
 
+import pandas as pd
+import pytest
+
 from sdv.datasets.demo import download_demo
 from sdv.metadata import Metadata
 from sdv.multi_table import DayZSynthesizer
@@ -173,3 +176,23 @@ def test_validate_parameters(self):
 
         # Run and Assert
         DayZSynthesizer.validate_parameters(metadata, dayz_parameters)
+
+    def test_create_parameters_empty_data(self):
+        """Test creating parameters with empty data."""
+        # Setup
+        data = {}
+        metadata = Metadata()
+
+        # Run and Assert
+        with pytest.raises(ValueError, match='Data is empty'):
+            DayZSynthesizer.create_parameters(data, metadata)
+
+    def test_create_parameters_empty_metadata(self):
+        """Test creating parameters with empty metadata."""
+        # Setup
+        data = {'table': pd.DataFrame({'col1': [1, 2, 3]})}
+        metadata = Metadata()
+
+        # Run and Assert
+        with pytest.raises(ValueError, match='Metadata is empty'):
+            DayZSynthesizer.create_parameters(data, metadata)

tests/integration/single_table/test_dayz.py

@@ -1,5 +1,8 @@
 """Integration tests for DayZ parameter detection."""
 
+import pandas as pd
+import pytest
+
 from sdv.datasets.demo import download_demo
 from sdv.metadata import Metadata
 from sdv.single_table import DayZSynthesizer
@@ -100,3 +103,23 @@ def test_validate_parameters(self):
 
         # Run and Assert
         DayZSynthesizer.validate_parameters(metadata, dayz_parameters)
+
+    def test_create_parameters_empty_data(self):
+        """Test creating parameters with empty data."""
+        # Setup
+        data = pd.DataFrame()
+        metadata = Metadata()
+
+        # Run and Assert
+        with pytest.raises(ValueError, match='Data is empty'):
+            DayZSynthesizer.create_parameters(data, metadata)
+
+    def test_create_parameters_empty_metadata(self):
+        """Test creating parameters with empty metadata."""
+        # Setup
+        data = pd.DataFrame({'col1': [1, 2, 3]})
+        metadata = Metadata()
+
+        # Run and Assert
+        with pytest.raises(ValueError, match='Metadata is empty'):
+            DayZSynthesizer.create_parameters(data, metadata)

tests/unit/multi_table/test_dayz.py

@@ -4,6 +4,7 @@
 import pandas as pd
 import pytest
 
+from sdv.datasets.demo import download_demo
 from sdv.errors import SynthesizerInputError, SynthesizerProcessingError
 from sdv.metadata import Metadata
 from sdv.multi_table.dayz import (
@@ -74,7 +75,7 @@ def test__validate_relationship_structure():
 
     # Run and Assert
     expected_bad_relationships_value_msg = re.escape(
-        "The 'relationships' parameter value must be a list."
+        "The 'relationships' parameter value must be a list of dictionaries."
     )
     with pytest.raises(SynthesizerProcessingError, match=expected_bad_relationships_value_msg):
         _validate_relationship_structure(bad_relationships_value)
@@ -320,3 +321,33 @@ def test_validate_parameters(self, mock__validate_parameters, metadata):
 
         # Assert
         mock__validate_parameters.assert_called_once_with(metadata, dayz_parameters)
+
+    def test__validate_relationships_is_list_of_dicts(self, metadata):
+        """Test that 'relationships' must be a list of dicts."""
+        # Run and Assert
+        expected_msg = re.escape(
+            "The 'relationships' parameter value must be a list of dictionaries."
+        )
+        with pytest.raises(SynthesizerProcessingError, match=expected_msg):
+            DayZSynthesizer.validate_parameters(metadata, {'relationships': {'a', 'b', 'c'}})
+
+        with pytest.raises(SynthesizerProcessingError, match=expected_msg):
+            DayZSynthesizer.validate_parameters(metadata, {'relationships': ['a', 'b', 'c']})
+
+    def test__validate_min_cardinality_allows_zero(self):
+        """Test that min_cardinality=0 is allowed and does not raise."""
+        # Setup
+        data, metadata = download_demo('multi_table', 'financial_v1')
+        dayz_parameters = DayZSynthesizer.create_parameters(data, metadata)
+        dayz_parameters['relationships'] = [
+            {
+                'parent_table_name': 'district',
+                'parent_primary_key': 'district_id',
+                'child_table_name': 'account',
+                'child_foreign_key': 'district_id',
+                'min_cardinality': 0,
+            }
+        ]
+
+        # Run
+        DayZSynthesizer.validate_parameters(metadata, dayz_parameters)

tests/unit/single_table/test__dayz_utils.py

@@ -96,9 +96,10 @@ def test_create_parameters(mock_detect_table, mock_detect_column, tmp_path):
         }
     }
 
-    data = pd.DataFrame()
+    data = pd.DataFrame({'col1': [1, 2, 3], 'col2': [4, 5, 6]})
     metadata = Mock()
     metadata._get_single_table_name.return_value = 'table_name'
+    metadata.tables = {'table_name': Mock()}
 
     # Run
     result = create_parameters(data, metadata, output_filename=output_filename)