[DayZ Parameters] Make create_parameters use a fall back to default parameters if parameters cannot be detected (#2715)

Co-authored-by: R-Palazzo <116157184+R-Palazzo@users.noreply.github.com>

Author: fealho

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,40 +110,17 @@ 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}
 

tests/unit/single_table/test_dayz.py

@@ -1,6 +1,7 @@
 import re
 from unittest.mock import call, patch
 
+import numpy as np
 import pandas as pd
 import pytest
 
@@ -432,3 +433,93 @@ def test__validate_parameters_errors_with_relationships(self):
         )
         with pytest.raises(SynthesizerProcessingError, match=expected_error_msg):
             DayZSynthesizer.validate_parameters(metadata, dayz_parameters)
+
+    def test_create_parameters_returns_valid_defaults(self):
+        """Test create_parameters returns valid defaults."""
+        # Setup
+        data = pd.DataFrame({'col': [np.nan]})
+        metadata = Metadata.detect_from_dataframe(data)
+
+        # Run
+        params = DayZSynthesizer.create_parameters(data, metadata)
+
+        # Assert
+        assert params == {
+            'tables': {
+                'table': {
+                    'columns': {
+                        'col': {'missing_values_proportion': 1.0},
+                    },
+                    'num_rows': 1,
+                },
+            },
+            'DAYZ_SPEC_VERSION': 'V1',
+        }
+
+    def test_create_parameters_all_null_categorical_column(self):
+        """Categorical column with all nulls should not have the category_values key parameter."""
+        # Setup
+        data = pd.DataFrame({'col': [None, None, np.nan, pd.NA]})
+        metadata = Metadata.detect_from_dataframe(data)
+
+        # Run
+        params = DayZSynthesizer.create_parameters(data, metadata)
+
+        # Assert
+        assert params == {
+            'tables': {
+                'table': {
+                    'columns': {
+                        'col': {'missing_values_proportion': 1.0},
+                    },
+                    'num_rows': 4,
+                },
+            },
+            'DAYZ_SPEC_VERSION': 'V1',
+        }
+
+    def test_create_parameters_all_null_numerical_column(self):
+        """Numerical column with all nulls should produce empty min/max values."""
+        # Setup
+        data = pd.DataFrame({'col': [np.nan]})
+        metadata = Metadata()
+        metadata.add_table('table')
+        metadata.add_column('col', 'table', sdtype='numerical')
+
+        # Run
+        params = DayZSynthesizer.create_parameters(data, metadata)
+
+        # Assert
+        assert params == {
+            'tables': {
+                'table': {
+                    'columns': {
+                        'col': {'missing_values_proportion': 1.0},
+                    },
+                    'num_rows': 1,
+                },
+            },
+            'DAYZ_SPEC_VERSION': 'V1',
+        }
+
+    def test_create_parameters_all_null_datetime_column(self):
+        """Datetime column with all nulls should omit start/end timestamps."""
+        # Setup
+        data = pd.DataFrame({'col': pd.to_datetime([None, None])})
+        metadata = Metadata.detect_from_dataframe(data)
+
+        # Run
+        params = DayZSynthesizer.create_parameters(data, metadata)
+
+        # Assert
+        assert params == {
+            'tables': {
+                'table': {
+                    'columns': {
+                        'col': {'missing_values_proportion': 1.0},
+                    },
+                    'num_rows': 2,
+                },
+            },
+            'DAYZ_SPEC_VERSION': 'V1',
+        }