sdgym 0.16.1.dev0__tar.gz → 0.16.2.dev0__tar.gz

{sdgym-0.16.1.dev0/sdgym.egg-info → sdgym-0.16.2.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sdgym
-Version: 0.16.1.dev0
+Version: 0.16.2.dev0
 Summary: Benchmark tabular synthetic data generators using a variety of datasets
 Author-email: "DataCebo, Inc." <info@sdv.dev>
 License-Expression: BUSL-1.1
@@ -63,10 +63,9 @@ Requires-Dist: torch>=2.6.0; python_version >= "3.13" and python_version < "3.14
 Requires-Dist: torch>=2.9.0; python_version >= "3.14"
 Requires-Dist: tqdm>=4.66.3
 Requires-Dist: XlsxWriter>=1.2.8
-Requires-Dist: rdt<2,>=1.18.2; python_version < "3.14"
-Requires-Dist: rdt<2,>=1.20.0; python_version >= "3.14"
-Requires-Dist: sdmetrics>=0.29.0
-Requires-Dist: sdv<2,>=1.37.0
+Requires-Dist: sdmetrics>=0.32.0
+Requires-Dist: rdt<3,>=2.0.0
+Requires-Dist: sdv<3,>=2.0.0
 Provides-Extra: dask
 Requires-Dist: dask; extra == "dask"
 Requires-Dist: distributed; extra == "dask"

{sdgym-0.16.1.dev0 → sdgym-0.16.2.dev0}/pyproject.toml

@@ -61,10 +61,9 @@ dependencies = [
     "torch>=2.9.0;python_version>='3.14'",
     'tqdm>=4.66.3',
     'XlsxWriter>=1.2.8',
-    "rdt>=1.18.2,<2;python_version<'3.14'",
-    "rdt>=1.20.0,<2;python_version>='3.14'",
-    "sdmetrics>=0.29.0",
-    "sdv>=1.37.0,<2",
+    "sdmetrics>=0.32.0",
+    "rdt>=2.0.0,<3",
+    "sdv>=2.0.0,<3",
 ]
 
 [project.urls]
@@ -177,7 +176,7 @@ namespaces = false
 version = {attr = 'sdgym.__version__'}
 
 [tool.bumpversion]
-current_version = "0.16.1.dev0"
+current_version = "0.16.2.dev0"
 parse = '(?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)(\.(?P<release>[a-z]+)(?P<candidate>\d+))?'
 serialize = [
     '{major}.{minor}.{patch}.{release}{candidate}',

{sdgym-0.16.1.dev0 → sdgym-0.16.2.dev0}/sdgym/__init__.py

@@ -8,7 +8,7 @@ __author__ = 'DataCebo, Inc.'
 __copyright__ = 'Copyright (c) 2022 DataCebo, Inc.'
 __email__ = 'info@sdv.dev'
 __license__ = 'BSL-1.1'
-__version__ = '0.16.1.dev0'
+__version__ = '0.16.2.dev0'
 
 import logging
 

{sdgym-0.16.1.dev0 → sdgym-0.16.2.dev0}/sdgym/_benchmark/credentials_utils.py

@@ -13,5 +13,5 @@ def sdv_install_cmd(credentials):
 pip install sdv-installer
 
 python -c "from sdv_installer.installation.installer import install_packages; \\
-install_packages(username='{username}', license_key='{license_key}', version='0.53')"
+install_packages(username='{username}', license_key='{license_key}')"
 """)

{sdgym-0.16.1.dev0 → sdgym-0.16.2.dev0}/sdgym/_dataset_utils.py

@@ -8,7 +8,7 @@ from zipfile import ZipFile
 import numpy as np
 import pandas as pd
 from sdv.metadata import Metadata
-from sdv.utils import poc
+from sdv.utils import get_random_subset
 
 LOGGER = logging.getLogger(__name__)
 
@@ -77,7 +77,7 @@ def _get_multi_table_dataset_subset(data, metadata_dict):
         data[table_name] = data[table_name][list(table.columns)]
 
     # Subsample the data mantaining the referential integrity
-    data = poc.get_random_subset(
+    data = get_random_subset(
         data=data,
         metadata=metadata,
         main_table_name=largest_table_name,
@@ -122,9 +122,12 @@ def _get_dataset_subset(data, metadata_dict, modality):
     filtered = _filter_columns(columns=columns, mandatory_columns=mandatory_columns)
 
     table_info['columns'] = filtered
-    data = data[list(filtered)]
-    max_rows = min(MAX_NUM_ROWS, len(data))
-    data = data.sample(max_rows)
+    is_dict = isinstance(data, dict)
+    table_data = data[table_name] if is_dict else data
+    table_data = table_data[list(filtered)]
+    max_rows = min(MAX_NUM_ROWS, len(table_data))
+    table_data = table_data.sample(max_rows)
+    data = {table_name: table_data} if is_dict else table_data
 
     return data, metadata_dict
 
@@ -137,9 +140,6 @@ def _read_zipped_data(zip_file_path, modality):
                 key = Path(file_name).stem
                 data[key] = _read_csv_from_zip(zf, csv_file_name=file_name)
 
-    if modality != 'multi_table':
-        data = next(iter(data.values()))
-
     return data
 
 

{sdgym-0.16.1.dev0 → sdgym-0.16.2.dev0}/sdgym/benchmark.py

@@ -25,18 +25,7 @@ import pandas as pd
 import tqdm
 import yaml
 from botocore.config import Config
-from sdmetrics.reports.multi_table import (
-    DiagnosticReport as MultiTableDiagnosticReport,
-)
-from sdmetrics.reports.multi_table import (
-    QualityReport as MultiTableQualityReport,
-)
-from sdmetrics.reports.single_table import (
-    DiagnosticReport as SingleTableDiagnosticReport,
-)
-from sdmetrics.reports.single_table import (
-    QualityReport as SingleTableQualityReport,
-)
+from sdmetrics.reports import DiagnosticReport, QualityReport
 from sdmetrics.single_table import DCRBaselineProtection
 
 from sdgym.datasets import (
@@ -60,6 +49,7 @@ from sdgym.s3 import (
 from sdgym.synthesizers import MultiTableUniformSynthesizer, UniformSynthesizer
 from sdgym.synthesizers.base import BaselineSynthesizer
 from sdgym.utils import (
+    _get_single_table_dataframe,
     calculate_score_time,
     convert_metadata_to_sdmetrics,
     format_exception,
@@ -515,7 +505,8 @@ def _synthesize(
         if modality == 'multi_table':
             synthetic_data = sample_from_synthesizer(fitted_synthesizer, 1.0)
         else:
-            synthetic_data = sample_from_synthesizer(fitted_synthesizer, n_samples=len(data))
+            num_rows = len(_get_single_table_dataframe(data))
+            synthetic_data = sample_from_synthesizer(fitted_synthesizer, n_samples=num_rows)
 
         sample_end = get_utc_now()
         sample_time = sample_end - train_end
@@ -530,9 +521,9 @@ def _synthesize(
                 result_writer.write_zipped_dataframes(
                     synthetic_data, synthesizer_path['synthetic_data']
                 )
-
             else:
-                result_writer.write_dataframe(synthetic_data, synthesizer_path['synthetic_data'])
+                synthetic_table = _get_single_table_dataframe(synthetic_data)
+                result_writer.write_dataframe(synthetic_table, synthesizer_path['synthetic_data'])
 
         return synthetic_data, train_time, sample_time, synthesizer_size, peak_memory
 
@@ -579,8 +570,12 @@ def _compute_scores(
     metrics = metrics or []
     if modality == 'single_table':
         sdmetrics_metadata = convert_metadata_to_sdmetrics(metadata)
+        sdmetrics_real_data = _get_single_table_dataframe(real_data)
+        sdmetrics_synthetic_data = _get_single_table_dataframe(synthetic_data)
     else:
         sdmetrics_metadata = metadata
+        sdmetrics_real_data = real_data
+        sdmetrics_synthetic_data = synthetic_data
 
     if len(metrics) > 0:
         metrics, metric_kwargs = get_metrics(metrics, modality=modality)
@@ -600,7 +595,7 @@ def _compute_scores(
             start = get_utc_now()
             try:
                 LOGGER.info('Computing %s on dataset %s', metric_name, dataset_name)
-                metric_args = (real_data, synthetic_data, sdmetrics_metadata)
+                metric_args = (sdmetrics_real_data, sdmetrics_synthetic_data, sdmetrics_metadata)
                 score = metric.compute(*metric_args, **metric_kwargs.get(metric_name, {}))
                 normalized_score = metric.normalize(score)
             except Exception:
@@ -620,23 +615,15 @@ def _compute_scores(
 
     if compute_diagnostic_score:
         start = get_utc_now()
-        if modality == 'single_table':
-            diagnostic_report = SingleTableDiagnosticReport()
-        else:
-            diagnostic_report = MultiTableDiagnosticReport()
-
-        diagnostic_report.generate(real_data, synthetic_data, sdmetrics_metadata, verbose=False)
+        diagnostic_report = DiagnosticReport()
+        diagnostic_report.generate(real_data, synthetic_data, metadata, verbose=False)
         output['diagnostic_score_time'] = calculate_score_time(start)
         output['diagnostic_score'] = diagnostic_report.get_score()
 
     if compute_quality_score:
         start = get_utc_now()
-        if modality == 'single_table':
-            quality_report = SingleTableQualityReport()
-        else:
-            quality_report = MultiTableQualityReport()
-
-        quality_report.generate(real_data, synthetic_data, sdmetrics_metadata, verbose=False)
+        quality_report = QualityReport()
+        quality_report.generate(real_data, synthetic_data, metadata, verbose=False)
         output['quality_score_time'] = calculate_score_time(start)
         output['quality_score'] = quality_report.get_score()
         if synthesizer_path is not None and result_writer is not None:
@@ -644,7 +631,7 @@ def _compute_scores(
 
     if compute_privacy_score:
         start = get_utc_now()
-        num_rows = len(synthetic_data)
+        num_rows = len(sdmetrics_synthetic_data)
         # parameters were determined by running experiments with all datasets
         # and tweaking num_rows_subsample and num_iterations until
         # absolute difference from real score was close (while keeping runtime low)
@@ -652,8 +639,8 @@ def _compute_scores(
         num_rows_subsample = math.floor(num_rows * 0.60)
         num_iterations = 2
         score = DCRBaselineProtection.compute_breakdown(
-            real_data=real_data,
-            synthetic_data=synthetic_data,
+            real_data=sdmetrics_real_data,
+            synthetic_data=sdmetrics_synthetic_data,
             table_name=dataset_name,
             metadata=sdmetrics_metadata,
             num_rows_subsample=num_rows_subsample,

{sdgym-0.16.1.dev0 → sdgym-0.16.2.dev0}/sdgym/datasets.py

@@ -12,12 +12,13 @@ import pandas as pd
 from sdv.datasets.demo import (
     _find_data_zip_key,
     _get_data_from_bucket,
-    _get_first_v1_metadata_bytes,
+    _get_first_v2_metadata_bytes,
     _get_metadata,
     _list_objects,
     _load_data_from_zip,
     download_demo,
 )
+from sdv.metadata import Metadata
 
 from sdgym._dataset_utils import (
     _get_dataset_subset,
@@ -178,24 +179,35 @@ def get_data_and_metadata_from_path(dataset_path, modality):
             interpret and load the dataset (e.g., ``'single_table'``, ``'multi_table'``).
 
     Returns:
-        tuple[pd.DataFrame | dict, dict | None]:
+        tuple[dict | None, dict | None]:
             A tuple containing:
-                - The loaded dataset as a ``pandas.DataFrame`` or a dictionary with
-                  ``pandas.DataFrame`` if ``multi_table``.
-            - The dataset metadata as a dictionary.
+                - The loaded dataset as a dictionary mapping table name to
+                  ``pandas.DataFrame``.
+                - The dataset metadata as a dictionary.
     """
     metadata_dict = None
     data = None
     for file_name in dataset_path.iterdir():
         is_metadata = 'metadata' in file_name.stem and file_name.suffix == '.json'
-        if (is_metadata and metadata_dict is None) or file_name.name == 'metadata.json':
+        if (is_metadata and metadata_dict is None) or file_name.name == 'metadata_v2.json':
             metadata_dict = _read_metadata_json(file_name)
         elif 'data' in file_name.stem and file_name.suffix == '.zip':
             data = _read_zipped_data(zip_file_path=(file_name), modality=modality)
 
+    if modality == 'single_table' and data is not None:
+        data = _set_single_table_as_dict(data, metadata_dict)
+
     return data, metadata_dict
 
 
+def _set_single_table_as_dict(data, metadata_dict):
+    if isinstance(data, dict):
+        return data
+
+    table_name = Metadata.load_from_dict(metadata_dict)._get_single_table_name()
+    return {table_name: data}
+
+
 def _genereate_dataset_info(s3_client, bucket_name, contents):
     """Generate summarized dataset information from S3 bucket.
 
@@ -302,13 +314,10 @@ def _load_private_sdv_demo_dataset(modality, dataset_name, bucket, s3_client=Non
     contents = _list_objects(dataset_prefix, bucket=bucket_name, client=s3_client)
     data_key = _find_data_zip_key(contents, dataset_prefix, bucket_name)
     data_bytes = io.BytesIO(_get_data_from_bucket(data_key, bucket=bucket_name, client=s3_client))
-    metadata_bytes = _get_first_v1_metadata_bytes(
+    metadata_bytes = _get_first_v2_metadata_bytes(
         contents, dataset_prefix, bucket=bucket_name, client=s3_client
     )
     data = _load_data_from_zip(data_bytes, bucket_name, dataset_name)
-    if modality != 'multi_table':
-        data = data.popitem()[1]
-
     metadata = _get_metadata(metadata_bytes, dataset_name)
     return data, metadata.to_dict()
 
@@ -378,7 +387,7 @@ def load_dataset(
             columns. Defauts to ``False``.
 
     Returns:
-        pd.DataFrame | dict, dict:
+        tuple (dict[str, pd.DataFrame], dict):
             The data and medatata for a dataset.
     """
     s3_client = get_s3_client(

{sdgym-0.16.1.dev0 → sdgym-0.16.2.dev0}/sdgym/synthesizers/base.py

@@ -129,9 +129,8 @@ class BaselineSynthesizer(abc.ABC):
                 The number of samples to create.
 
         Returns:
-            pandas.DataFrame or dict:
-                The sampled data. If single-table, should be a DataFrame. If multi-table,
-                should be a dict mapping table name to DataFrame.
+            dict[str, pandas.DataFrame]:
+                The sampled data mapping table name to DataFrame.
         """
         return self._sample_from_synthesizer(synthesizer, n_samples)
 

{sdgym-0.16.1.dev0 → sdgym-0.16.2.dev0}/sdgym/synthesizers/column.py

@@ -8,6 +8,7 @@ from sdv.metadata import Metadata
 from sklearn.mixture import GaussianMixture
 
 from sdgym.synthesizers.base import BaselineSynthesizer
+from sdgym.synthesizers.utils import _get_single_table_name_and_dataframe
 
 LOGGER = logging.getLogger(__name__)
 
@@ -22,12 +23,12 @@ class ColumnSynthesizer(BaselineSynthesizer):
     _MODALITY_FLAG = 'single_table'
 
     def _fit(self, data, metadata):
+        table_name, table_data = _get_single_table_name_and_dataframe(data, metadata)
         hyper_transformer = HyperTransformer()
-        hyper_transformer.detect_initial_config(data)
+        hyper_transformer.detect_initial_config(table_data)
         supported_sdtypes = hyper_transformer._get_supported_sdtypes()
         config = {}
         if isinstance(metadata, Metadata):
-            table_name = metadata._get_single_table_name()
             columns = metadata.tables[table_name].columns
         else:
             columns = metadata.columns
@@ -48,14 +49,14 @@ class ColumnSynthesizer(BaselineSynthesizer):
 
         # This is done to match the behavior of the synthesizer for SDGym <= 0.6.0
         columns_to_remove = [
-            column_name for column_name, data in data.items() if data.dtype.kind in {'O', 'i'}
+            column_name for column_name, data in table_data.items() if data.dtype.kind in {'O', 'i'}
         ]
         hyper_transformer.remove_transformers(columns_to_remove)
 
-        hyper_transformer.fit(data)
-        transformed = hyper_transformer.transform(data)
+        hyper_transformer.fit(table_data)
+        transformed = hyper_transformer.transform(table_data)
 
-        self.length = len(data)
+        self.length = len(table_data)
         gm_models = {}
         for name, column in transformed.items():
             kind = column.dtype.kind
@@ -68,6 +69,7 @@ class ColumnSynthesizer(BaselineSynthesizer):
         self.hyper_transformer = hyper_transformer
         self.transformed_data = transformed
         self.gm_models = gm_models
+        self._table_name = table_name
 
     def _sample_from_synthesizer(self, synthesizer, n_samples):
         hyper_transformer = synthesizer.hyper_transformer
@@ -84,4 +86,4 @@ class ColumnSynthesizer(BaselineSynthesizer):
 
             sampled[name] = values
 
-        return hyper_transformer.reverse_transform(sampled)
+        return {synthesizer._table_name: hyper_transformer.reverse_transform(sampled)}

{sdgym-0.16.1.dev0 → sdgym-0.16.2.dev0}/sdgym/synthesizers/data_designer.py

@@ -306,14 +306,16 @@ class DataDesignerSynthesizer(BaselineSynthesizer):
     _MODALITY_FLAG = 'single_table'
 
     def _fit(self, data, metadata):
-        table_name = metadata._get_single_table_name()
         metadata.validate()
-        metadata.validate_data({table_name: data})
+        metadata.validate_data(data)
 
+        table_name = metadata._get_single_table_name()
+        table_data = data[table_name]
         model_kwargs = self._MODEL_KWARGS.copy() if self._MODEL_KWARGS else {}
         self._artifact_path = model_kwargs.pop('artifact_path', None)
         self._cleanup_artifacts = model_kwargs.pop('cleanup_artifacts', True)
-        self._config_builder = create_data_designer_config(data, metadata, **model_kwargs)
+        self._config_builder = create_data_designer_config(table_data, metadata, **model_kwargs)
+        self._table_name = table_name
 
     def _sample_from_synthesizer(self, synthesizer, n_sample):
         """Sample synthetic data with specified sample count."""
@@ -332,12 +334,12 @@ class DataDesignerSynthesizer(BaselineSynthesizer):
             artifact_path = Path(synthesizer._artifact_path)
 
         # A unique name keeps concurrent or repeated sample calls from sharing a folder.
-        dataset_name = f'dataset-{uuid.uuid4().hex}'
+        dataset_name = f'dataset-{synthesizer._table_name}-{uuid.uuid4().hex}'
         try:
             output = DataDesigner(artifact_path=artifact_path).create(
                 synthesizer._config_builder, num_records=n_sample, dataset_name=dataset_name
             )
-            return output.load_dataset()
+            return {synthesizer._table_name: output.load_dataset()}
         finally:
             if synthesizer._cleanup_artifacts:
                 to_remove = artifact_path if is_temporary else artifact_path / dataset_name

{sdgym-0.16.1.dev0 → sdgym-0.16.2.dev0}/sdgym/synthesizers/realtabformer.py

@@ -8,6 +8,7 @@ from functools import partialmethod
 import tqdm
 
 from sdgym.synthesizers.base import BaselineSynthesizer
+from sdgym.synthesizers.utils import _get_single_table_name_and_dataframe
 
 REMOVED_TRAINING_ARGS = ('overwrite_output_dir',)
 
@@ -49,14 +50,16 @@ class RealTabFormerSynthesizer(BaselineSynthesizer):
                 " dependencies by running  pip install sdgym['realtabformer'] "
             ) from exception
 
+        table_name, table_data = _get_single_table_name_and_dataframe(data, metadata)
         with prevent_tqdm_output():
             model_kwargs = self._MODEL_KWARGS.copy() if self._MODEL_KWARGS else {}
             model = REaLTabFormer(model_type='tabular', **model_kwargs)
             _remove_unsupported_training_args(model)
-            model.fit(data)
+            model.fit(table_data)
 
         self._internal_synthesizer = model
+        self._table_name = table_name
 
     def _sample_from_synthesizer(self, synthesizer, n_sample):
         """Sample synthetic data with specified sample count."""
-        return synthesizer._internal_synthesizer.sample(n_sample)
+        return {synthesizer._table_name: synthesizer._internal_synthesizer.sample(n_sample)}

{sdgym-0.16.1.dev0 → sdgym-0.16.2.dev0}/sdgym/synthesizers/sdv.py

@@ -50,7 +50,7 @@ def _fit(self, data, metadata):
 def _sample_from_synthesizer(self, synthesizer, sample_arg):
     LOGGER.info('Sampling %s', self.__class__.__name__)
     if self._MODALITY_FLAG == 'multi_table':
-        return synthesizer._internal_synthesizer.sample(scale=sample_arg)
+        return synthesizer._internal_synthesizer.sample_scale(scale=sample_arg)
 
     return synthesizer._internal_synthesizer.sample(num_rows=sample_arg)
 

{sdgym-0.16.1.dev0 → sdgym-0.16.2.dev0}/sdgym/synthesizers/tabddpm.py

@@ -23,6 +23,7 @@ from sklearn.preprocessing import OrdinalEncoder, QuantileTransformer
 from torch import Tensor
 
 from sdgym.synthesizers.base import BaselineSynthesizer
+from sdgym.synthesizers.utils import _get_single_table_name_and_dataframe
 
 CAT_MISSING_VALUE = '__nan__'
 
@@ -1196,12 +1197,14 @@ class TabDDPMSynthesizer(BaselineSynthesizer):
     _MODALITY_FLAG = 'single_table'
 
     def _fit(self, data, metadata):
+        table_name, table_data = _get_single_table_name_and_dataframe(data, metadata)
         model_kwargs = self._MODEL_KWARGS.copy() if self._MODEL_KWARGS else {}
         model = TabDDPM(metadata, **model_kwargs)
-        model.fit(data)
+        model.fit(table_data)
 
         self._internal_synthesizer = model
+        self._table_name = table_name
 
     def _sample_from_synthesizer(self, synthesizer, n_sample):
         """Sample synthetic data with specified sample count."""
-        return synthesizer._internal_synthesizer.sample(n_sample)
+        return {synthesizer._table_name: synthesizer._internal_synthesizer.sample(n_sample)}

{sdgym-0.16.1.dev0 → sdgym-0.16.2.dev0}/sdgym/synthesizers/uniform.py

@@ -8,6 +8,7 @@ import pandas as pd
 from rdt.hyper_transformer import HyperTransformer
 
 from sdgym.synthesizers.base import BaselineSynthesizer, MultiTableBaselineSynthesizer
+from sdgym.synthesizers.utils import _get_single_table_name_and_dataframe
 
 LOGGER = logging.getLogger(__name__)
 
@@ -21,22 +22,24 @@ class UniformSynthesizer(BaselineSynthesizer):
         super().__init__()
         self.hyper_transformer = None
         self.transformed_data = None
+        self._table_name = None
 
     def _fit(self, data, metadata):
         """Fit the synthesizer to the data.
 
         Args:
-            data (pd.DataFrame):
+            data (dict[str, pd.DataFrame]):
                 The data to fit the synthesizer to.
             metadata (sdv.metadata.Metadata):
                 The metadata describing the data.
         """
+        table_name, table_data = _get_single_table_name_and_dataframe(data, metadata)
         hyper_transformer = HyperTransformer()
-        hyper_transformer.detect_initial_config(data)
+        hyper_transformer.detect_initial_config(table_data)
         supported_sdtypes = hyper_transformer._get_supported_sdtypes()
         config = {}
-        table = next(iter(metadata.tables.values()))
-        for column_name, column in table.columns.items():
+        table_metadata = next(iter(metadata.tables.values()))
+        for column_name, column in table_metadata.columns.items():
             sdtype = column['sdtype']
             if sdtype in supported_sdtypes:
                 config[column_name] = sdtype
@@ -59,15 +62,16 @@ class UniformSynthesizer(BaselineSynthesizer):
         # This is done to match the behavior of the synthesizer for SDGym <= 0.6.0
         columns_to_remove = [
             column_name
-            for column_name, column_data in data.items()
+            for column_name, column_data in table_data.items()
             if column_data.dtype.kind in {'O', 'i', 'b'}
         ]
         hyper_transformer.remove_transformers(columns_to_remove)
 
-        hyper_transformer.fit(data)
-        transformed = hyper_transformer.transform(data)
+        hyper_transformer.fit(table_data)
+        transformed = hyper_transformer.transform(table_data)
         self.hyper_transformer = hyper_transformer
         self.transformed_data = transformed
+        self._table_name = table_name
 
     def _sample_from_synthesizer(self, synthesizer, n_samples):
         hyper_transformer = synthesizer.hyper_transformer
@@ -85,7 +89,7 @@ class UniformSynthesizer(BaselineSynthesizer):
                 values = np.random.uniform(column.min(), column.max(), size=n_samples)
             sampled[name] = values
 
-        return hyper_transformer.reverse_transform(sampled)
+        return {synthesizer._table_name: hyper_transformer.reverse_transform(sampled)}
 
 
 class MultiTableUniformSynthesizer(MultiTableBaselineSynthesizer):
@@ -112,7 +116,7 @@ class MultiTableUniformSynthesizer(MultiTableBaselineSynthesizer):
         for table_name, table_data in data.items():
             table_metadata = metadata.get_table_metadata(table_name)
             synthesizer = UniformSynthesizer()
-            synthesizer._fit(table_data, table_metadata)
+            synthesizer._fit({table_name: table_data}, table_metadata)
             self.num_rows_per_table[table_name] = len(table_data)
             self.table_synthesizers[table_name] = synthesizer
 
@@ -135,6 +139,6 @@ class MultiTableUniformSynthesizer(MultiTableBaselineSynthesizer):
             sampled_table = UniformSynthesizer().sample_from_synthesizer(
                 table_synthesizer, n_samples=n_samples
             )
-            sampled_data[table_name] = sampled_table
+            sampled_data[table_name] = sampled_table[table_name]
 
         return sampled_data

sdgym-0.16.2.dev0/sdgym/synthesizers/utils.py

@@ -0,0 +1,84 @@
+"""Utility functions for synthesizers in SDGym."""
+
+from sdv.metadata import Metadata
+
+from sdgym.synthesizers.base import BaselineSynthesizer
+
+
+def get_available_single_table_synthesizers():
+    """List all available single-table synthesizers in SDGym.
+
+    Returns:
+        list:
+            A sorted list of available single-table synthesizer names.
+    """
+    return sorted(BaselineSynthesizer._get_supported_synthesizers('single_table'))
+
+
+def get_available_multi_table_synthesizers():
+    """List all available multi-table synthesizers in SDGym.
+
+    Returns:
+        list:
+            A sorted list of available multi-table synthesizer names.
+    """
+    return sorted(BaselineSynthesizer._get_supported_synthesizers('multi_table'))
+
+
+def _get_supported_synthesizers():
+    """Get SDGym supported synthesizers.
+
+    Returns:
+        list:
+            A list of available SDGym supported synthesizer names.
+    """
+    synthesizers = []
+    for modality in ['single_table', 'multi_table']:
+        synthesizers.extend(BaselineSynthesizer._get_supported_synthesizers(modality))
+
+    return sorted(synthesizers)
+
+
+def _get_single_table_name(data, metadata):
+    """Get the table name from metadata or data.
+
+    Args:
+        data (dict[str, pd.DataFrame]):
+            Dictionary mapping the name to the dataframe. Expected to
+            be a dictionary of one dataframe.
+        metadata (sdv.Metadata):
+            The metadata.
+
+    Returns:
+        str:
+            The name of the table.
+    """
+    if isinstance(metadata, Metadata):
+        table_name = metadata._get_single_table_name()
+    else:
+        if len(data) != 1:
+            raise ValueError(
+                "The data contains more than one table. Could not determine 'table name'."
+            )
+
+        table_name = next(iter(data))
+
+    return table_name
+
+
+def _get_single_table_name_and_dataframe(data, metadata):
+    """Get the table name and its dataframe from single table data.
+
+    Args:
+        data (dict[str, pd.DataFrame]):
+            Dictionary mapping the name to the dataframe. Expected to
+            be a dictionary of one dataframe.
+        metadata (sdv.Metadata):
+            The metadata.
+
+    Returns:
+        tuple[str, pd.DataFrame]:
+            The name of the table and its dataframe.
+    """
+    table_name = _get_single_table_name(data, metadata)
+    return table_name, data[table_name]

{sdgym-0.16.1.dev0 → sdgym-0.16.2.dev0}/sdgym/utils.py

@@ -209,3 +209,20 @@ def _set_column_width(writer, df, sheet_name):
 def _is_list_of_type(values, type_to_check=str):
     """Checks that 'values' is a list and all elements are of type 'type_to_check'."""
     return isinstance(values, list) and all(isinstance(value, type_to_check) for value in values)
+
+
+def _get_single_table_dataframe(data):
+    """Get the only table from a dictionary of one dataframe."""
+    if not isinstance(data, dict) or not all(
+        isinstance(table, pd.DataFrame) for table in data.values()
+    ):
+        raise ValueError(
+            'The data must be a dictionary mapping a single table name to a dataframe.'
+        )
+
+    if len(data) != 1:
+        raise ValueError(
+            f'The data must contain exactly one table, but {len(data)} tables were found.'
+        )
+
+    return next(iter(data.values()))

{sdgym-0.16.1.dev0 → sdgym-0.16.2.dev0/sdgym.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sdgym
-Version: 0.16.1.dev0
+Version: 0.16.2.dev0
 Summary: Benchmark tabular synthetic data generators using a variety of datasets
 Author-email: "DataCebo, Inc." <info@sdv.dev>
 License-Expression: BUSL-1.1
@@ -63,10 +63,9 @@ Requires-Dist: torch>=2.6.0; python_version >= "3.13" and python_version < "3.14
 Requires-Dist: torch>=2.9.0; python_version >= "3.14"
 Requires-Dist: tqdm>=4.66.3
 Requires-Dist: XlsxWriter>=1.2.8
-Requires-Dist: rdt<2,>=1.18.2; python_version < "3.14"
-Requires-Dist: rdt<2,>=1.20.0; python_version >= "3.14"
-Requires-Dist: sdmetrics>=0.29.0
-Requires-Dist: sdv<2,>=1.37.0
+Requires-Dist: sdmetrics>=0.32.0
+Requires-Dist: rdt<3,>=2.0.0
+Requires-Dist: sdv<3,>=2.0.0
 Provides-Extra: dask
 Requires-Dist: dask; extra == "dask"
 Requires-Dist: distributed; extra == "dask"

{sdgym-0.16.1.dev0 → sdgym-0.16.2.dev0}/sdgym.egg-info/requires.txt

@@ -10,8 +10,9 @@ psutil>=7.0.0
 tabulate<0.9,>=0.8.3
 tqdm>=4.66.3
 XlsxWriter>=1.2.8
-sdmetrics>=0.29.0
-sdv<2,>=1.37.0
+sdmetrics>=0.32.0
+rdt<3,>=2.0.0
+sdv<3,>=2.0.0
 
 [:python_version < "3.10"]
 numpy>=1.22.2
@@ -24,7 +25,6 @@ torch>=1.13.0
 
 [:python_version < "3.14"]
 cloudpickle>=2.1.0
-rdt<2,>=1.18.2
 
 [:python_version >= "3.10" and python_version < "3.11"]
 scikit-learn>=1.1.0
@@ -59,7 +59,6 @@ pandas<3,>=2.3.3
 scikit-learn>=1.8.0
 scipy>=1.16.1
 torch>=2.9.0
-rdt<2,>=1.20.0
 
 [all]
 sdgym[dask,dev,test]

sdgym-0.16.1.dev0/sdgym/synthesizers/utils.py

@@ -1,37 +0,0 @@
-"""Utility functions for synthesizers in SDGym."""
-
-from sdgym.synthesizers.base import BaselineSynthesizer
-
-
-def get_available_single_table_synthesizers():
-    """List all available single-table synthesizers in SDGym.
-
-    Returns:
-        list:
-            A sorted list of available single-table synthesizer names.
-    """
-    return sorted(BaselineSynthesizer._get_supported_synthesizers('single_table'))
-
-
-def get_available_multi_table_synthesizers():
-    """List all available multi-table synthesizers in SDGym.
-
-    Returns:
-        list:
-            A sorted list of available multi-table synthesizer names.
-    """
-    return sorted(BaselineSynthesizer._get_supported_synthesizers('multi_table'))
-
-
-def _get_supported_synthesizers():
-    """Get SDGym supported synthesizers.
-
-    Returns:
-        list:
-            A list of available SDGym supported synthesizer names.
-    """
-    synthesizers = []
-    for modality in ['single_table', 'multi_table']:
-        synthesizers.extend(BaselineSynthesizer._get_supported_synthesizers(modality))
-
-    return sorted(synthesizers)