sdmetrics 0.27.3.dev0__tar.gz → 0.28.1.dev0__tar.gz

{sdmetrics-0.27.3.dev0/sdmetrics.egg-info → sdmetrics-0.28.1.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sdmetrics
-Version: 0.27.3.dev0
+Version: 0.28.1.dev0
 Summary: Metrics for Synthetic Data Generation Projects
 Author-email: MIT Data To AI Lab <dailabmit@gmail.com>
 License-Expression: MIT

{sdmetrics-0.27.3.dev0 → sdmetrics-0.28.1.dev0}/pyproject.toml

@@ -148,7 +148,7 @@ convention = 'google'
 add-ignore = ['D107', 'D407', 'D417']
 
 [tool.bumpversion]
-current_version = "0.27.3.dev0"
+current_version = "0.28.1.dev0"
 parse = '(?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)(\.(?P<release>[a-z]+)(?P<candidate>\d+))?'
 serialize = [
     '{major}.{minor}.{patch}.{release}{candidate}',

{sdmetrics-0.27.3.dev0 → sdmetrics-0.28.1.dev0}/sdmetrics/__init__.py

@@ -4,7 +4,7 @@
 
 __author__ = 'MIT Data To AI Lab'
 __email__ = 'dailabmit@gmail.com'
-__version__ = '0.27.3.dev0'
+__version__ = '0.28.1.dev0'
 
 import sys
 import warnings as python_warnings

{sdmetrics-0.27.3.dev0 → sdmetrics-0.28.1.dev0}/sdmetrics/_utils_metadata.py

@@ -2,7 +2,7 @@ import warnings
 
 import pandas as pd
 
-from sdmetrics.utils import is_datetime
+from sdmetrics.utils import get_columns_from_metadata, is_datetime
 
 MODELABLE_SDTYPES = ('numerical', 'datetime', 'categorical', 'boolean')
 
@@ -17,42 +17,40 @@ def _validate_metadata_dict(metadata):
         )
 
 
-def _validate_single_table_metadata(metadata):
+def _validate_columns_exist_in_single_table_metadata(metadata):
     """Validate the metadata for a single table."""
     _validate_metadata_dict(metadata)
     if 'columns' not in metadata:
         raise ValueError(
-            "Single-table metadata must include a 'columns' key that maps column names"
+            "Each table in the metadata must include a 'columns' key that maps column names"
             ' to their corresponding information.'
         )
 
 
-def _validate_multi_table_metadata(metadata):
-    """Validate the metadata for multiple tables."""
+def _validate_metadata(metadata):
+    """Validate the metadata."""
     _validate_metadata_dict(metadata)
     if 'tables' not in metadata:
-        raise ValueError(
-            "Multi-table metadata must include a 'tables' key that maps table names"
-            ' to their respective metadata.'
-        )
+        _validate_columns_exist_in_single_table_metadata(metadata)
+        return
+
     for table_name, table_metadata in metadata['tables'].items():
         try:
-            _validate_single_table_metadata(table_metadata)
+            _validate_columns_exist_in_single_table_metadata(table_metadata)
         except ValueError as e:
             raise ValueError(f"Error in table '{table_name}': {str(e)}")
 
 
-def _validate_metadata(metadata):
-    """Validate the metadata."""
+def _validate_unified_metadata(metadata):
+    """Validate the unified metadata object."""
     _validate_metadata_dict(metadata)
-    if ('columns' not in metadata) and ('tables' not in metadata):
+    if 'tables' not in metadata:
         raise ValueError(
-            "Metadata must include either a 'columns' key for single-table metadata"
-            " or a 'tables' key for multi-table metadata."
+            "Metadata must include a 'tables' key that maps table names"
+            ' to their respective metadata.'
         )
 
-    if 'tables' in metadata:
-        _validate_multi_table_metadata(metadata)
+    _validate_metadata(metadata)
 
 
 def handle_single_and_multi_table(single_table_func):
@@ -94,11 +92,9 @@ def _convert_datetime_column(column_name, column_data, column_metadata):
 @handle_single_and_multi_table
 def _convert_datetime_columns(data, metadata):
     """Convert datetime columns to datetime type."""
-    for column in metadata['columns']:
-        if metadata['columns'][column]['sdtype'] == 'datetime':
-            data[column] = _convert_datetime_column(
-                column, data[column], metadata['columns'][column]
-            )
+    for column, column_metadata in get_columns_from_metadata(metadata).items():
+        if column_metadata['sdtype'] == 'datetime':
+            data[column] = _convert_datetime_column(column, data[column], column_metadata)
 
     return data
 
@@ -106,7 +102,7 @@ def _convert_datetime_columns(data, metadata):
 @handle_single_and_multi_table
 def _remove_missing_columns_metadata(data, metadata):
     """Remove columns that are not present in the metadata."""
-    columns_in_metadata = set(metadata['columns'].keys())
+    columns_in_metadata = set(get_columns_from_metadata(metadata).keys())
     columns_in_data = set(data.columns)
     columns_to_remove = columns_in_data - columns_in_metadata
     extra_metadata_columns = columns_in_metadata - columns_in_data
@@ -126,7 +122,9 @@ def _remove_missing_columns_metadata(data, metadata):
         )
 
     data = data.drop(columns=columns_to_remove)
-    column_intersection = [column for column in data.columns if column in metadata['columns']]
+    column_intersection = [
+        column for column in data.columns if column in get_columns_from_metadata(metadata)
+    ]
 
     return data[column_intersection]
 
@@ -138,8 +136,8 @@ def _remove_non_modelable_columns(data, metadata):
     All modelable columns are numerical, datetime, categorical, or boolean sdtypes.
     """
     columns_modelable = []
-    for column in metadata['columns']:
-        column_sdtype = metadata['columns'][column]['sdtype']
+    for column, column_metadata in get_columns_from_metadata(metadata).items():
+        column_sdtype = column_metadata['sdtype']
         if column_sdtype in MODELABLE_SDTYPES and column in data.columns:
             columns_modelable.append(column)
 

sdmetrics-0.28.1.dev0/sdmetrics/demos/single_table/metadata.json

@@ -0,0 +1,72 @@
+{
+    "tables": {
+        "student_placements": {
+            "primary_key": "student_id",
+            "columns": {
+                "start_date": {
+                    "sdtype": "datetime",
+                    "datetime_format": "%Y-%m-%d"
+                },
+                "end_date": {
+                    "sdtype": "datetime",
+                    "datetime_format": "%Y-%m-%d"
+                },
+                "salary": {
+                    "sdtype": "numerical",
+                    "computer_representation": "Int64"
+                },
+                "duration": {
+                    "sdtype": "numerical",
+                    "computer_representation": "Int64"
+                },
+                "student_id": {
+                    "sdtype": "id",
+                    "regex_format": "\\d{30}"
+                },
+                "high_perc": {
+                    "sdtype": "numerical",
+                    "computer_representation": "Float"
+                },
+                "high_spec": {
+                    "sdtype": "categorical"
+                },
+                "mba_spec": {
+                    "sdtype": "categorical"
+                },
+                "second_perc": {
+                    "sdtype": "numerical",
+                    "computer_representation": "Float"
+                },
+                "gender": {
+                    "sdtype": "categorical"
+                },
+                "degree_perc": {
+                    "sdtype": "numerical",
+                    "computer_representation": "Float"
+                },
+                "placed": {
+                    "sdtype": "boolean"
+                },
+                "experience_years": {
+                    "sdtype": "numerical",
+                    "computer_representation": "Float"
+                },
+                "employability_perc": {
+                    "sdtype": "numerical",
+                    "computer_representation": "Float"
+                },
+                "mba_perc": {
+                    "sdtype": "numerical",
+                    "computer_representation": "Float"
+                },
+                "work_experience": {
+                    "sdtype": "boolean"
+                },
+                "degree_type": {
+                    "sdtype": "categorical"
+                }
+            }
+        }
+    },
+    "METADATA_SPEC_VERSION": "SINGLE_TABLE_V1"
+}

sdmetrics-0.28.1.dev0/sdmetrics/demos/timeseries/metadata.json

@@ -0,0 +1,33 @@
+{
+    "tables": {
+        "timeseries": {
+            "columns": {
+                "region": {
+                    "sdtype": "categorical"
+                },
+                "store_id": {
+                    "sdtype": "numerical",
+                    "computer_representation": "Int64"
+                },
+                "nb_customers": {
+                    "sdtype": "numerical",
+                    "computer_representation": "Int64"
+                },
+                "total_sales": {
+                    "sdtype": "numerical",
+                    "computer_representation": "Float"
+                },
+                "date": {
+                    "sdtype": "datetime"
+                },
+                "day_of_week": {
+                    "sdtype": "numerical",
+                    "computer_representation": "Int64"
+                }
+            },
+            "sequence_key": "store_id",
+            "sequence_index": "date"
+        }
+    },
+    "METADATA_SPEC_VERSION": "SINGLE_TABLE_V1"
+}

{sdmetrics-0.27.3.dev0 → sdmetrics-0.28.1.dev0}/sdmetrics/demos.py

@@ -35,16 +35,11 @@ def load_demo(modality='multi_table'):
     with open(demo_path / 'metadata.json', 'r') as metadata_file:
         metadata = json.loads(metadata_file.read())
 
-    if modality == 'multi_table':
-        real_data = {}
-        synthetic_data = {}
-        for table, table_meta in metadata['tables'].items():
-            real_data[table] = _load_table(table_meta, demo_path / f'{table}_real.csv')
-            synthetic_data[table] = _load_table(table_meta, demo_path / f'{table}_synthetic.csv')
-
-    else:
-        real_data = _load_table(metadata, demo_path / 'real.csv')
-        synthetic_data = _load_table(metadata, demo_path / 'synthetic.csv')
+    real_data = {}
+    synthetic_data = {}
+    for table, table_meta in metadata['tables'].items():
+        real_data[table] = _load_table(table_meta, demo_path / f'{table}_real.csv')
+        synthetic_data[table] = _load_table(table_meta, demo_path / f'{table}_synthetic.csv')
 
     return real_data, synthetic_data, metadata
 

{sdmetrics-0.27.3.dev0 → sdmetrics-0.28.1.dev0}/sdmetrics/multi_table/detection/parent_child.py

@@ -2,7 +2,7 @@
 
 import numpy as np
 
-from sdmetrics._utils_metadata import _validate_multi_table_metadata
+from sdmetrics._utils_metadata import _validate_metadata
 from sdmetrics.multi_table.detection.base import DetectionMetric
 from sdmetrics.single_table.detection import LogisticDetection, SVCDetection
 from sdmetrics.utils import get_columns_from_metadata, nested_attrs_meta
@@ -38,7 +38,7 @@ class ParentChildDetectionMetric(
 
     @staticmethod
     def _extract_foreign_keys(metadata):
-        _validate_multi_table_metadata(metadata)
+        _validate_metadata(metadata)
         foreign_keys = []
         for child_table, child_meta in metadata['tables'].items():
             for child_key, field_meta in get_columns_from_metadata(child_meta).items():

{sdmetrics-0.27.3.dev0 → sdmetrics-0.28.1.dev0}/sdmetrics/multi_table/multi_single_table.py

@@ -6,7 +6,7 @@ from collections import defaultdict
 import numpy as np
 
 from sdmetrics import single_table
-from sdmetrics._utils_metadata import _validate_multi_table_metadata
+from sdmetrics._utils_metadata import _validate_metadata
 from sdmetrics.errors import IncomputableMetricError
 from sdmetrics.multi_table.base import MultiTableMetric
 from sdmetrics.utils import nested_attrs_meta
@@ -79,7 +79,7 @@ class MultiSingleTableMetric(MultiTableMetric, metaclass=nested_attrs_meta('sing
         if metadata is None:
             metadata = {'tables': defaultdict(type(None))}
 
-        _validate_multi_table_metadata(metadata)
+        _validate_metadata(metadata)
         scores = {}
         errors = {}
         for table_name, real_table in real_data.items():

sdmetrics-0.28.1.dev0/sdmetrics/reports/__init__.py

@@ -0,0 +1,38 @@
+"""Reports for sdmetrics."""
+
+from sdmetrics.reports.diagnostic_report import DiagnosticReport
+from sdmetrics.reports.quality_report import QualityReport
+
+__all__ = [
+    'DiagnosticReport',
+    'QualityReport',
+    'SingleTableQualityReport',  # noqa: F822
+    'SingleTableDiagnosticReport',  # noqa: F822
+    'MultiTableQualityReport',  # noqa: F822
+    'MultiTableDiagnosticReport',  # noqa: F822
+]
+
+
+def __getattr__(name):
+    """Lazy load deprecated report class aliases."""
+    if name == 'SingleTableQualityReport':
+        from sdmetrics.reports.single_table.quality_report import QualityReport
+
+        return QualityReport
+
+    if name == 'SingleTableDiagnosticReport':
+        from sdmetrics.reports.single_table.diagnostic_report import DiagnosticReport
+
+        return DiagnosticReport
+
+    if name == 'MultiTableQualityReport':
+        from sdmetrics.reports.multi_table.quality_report import QualityReport
+
+        return QualityReport
+
+    if name == 'MultiTableDiagnosticReport':
+        from sdmetrics.reports.multi_table.diagnostic_report import DiagnosticReport
+
+        return DiagnosticReport
+
+    raise AttributeError(f"module 'sdmetrics.reports' has no attribute '{name}'")

{sdmetrics-0.27.3.dev0 → sdmetrics-0.28.1.dev0}/sdmetrics/reports/base_report.py

@@ -15,6 +15,7 @@ import tqdm
 
 from sdmetrics._utils_metadata import _convert_datetime_column, _validate_metadata
 from sdmetrics.reports.utils import DEFAULT_NUM_ROWS_SUBSAMPLE
+from sdmetrics.utils import get_columns_from_metadata
 from sdmetrics.visualization import set_plotly_config
 
 
@@ -24,10 +25,13 @@ class BaseReport:
     This class creates a base report for single-table data.
     """
 
+    _skipped_property_message = 'This property was skipped.'
+
     def __init__(self):
         self._overall_score = None
         self.is_generated = False
         self._properties = {}
+        self._skipped_properties = set()
         self.num_rows_subsample = DEFAULT_NUM_ROWS_SUBSAMPLE
         self.report_info = {
             'report_type': self.__class__.__name__,
@@ -42,7 +46,7 @@ class BaseReport:
         """
         real_columns = set(real_data.columns)
         synthetic_columns = set(synthetic_data.columns)
-        metadata_columns = set(metadata['columns'].keys())
+        metadata_columns = set(get_columns_from_metadata(metadata).keys())
 
         missing_data = metadata_columns.difference(real_columns.union(synthetic_columns))
         missing_metadata = real_columns.union(synthetic_columns).difference(metadata_columns)
@@ -97,7 +101,7 @@ class BaseReport:
             metadata (dict):
                 The metadata, which contains each column's data type as well as relationships.
         """
-        for column, col_meta in metadata['columns'].items():
+        for column, col_meta in get_columns_from_metadata(metadata).items():
             if col_meta['sdtype'] == 'datetime':
                 real_col = real_data[column]
                 synth_col = synthetic_data[column]
@@ -117,6 +121,19 @@ class BaseReport:
         if verbose:
             sys.stdout.write(f'Overall Score (Average): {round(self._overall_score * 100, 2)}%\n\n')
 
+    def _get_skipped_properties(self, metadata):
+        """Return properties that should not be computed for the metadata.
+
+        Args:
+            metadata (dict):
+                The metadata dict.
+
+        Returns:
+            set[str]:
+                Names of properties to skip.
+        """
+        return set()
+
     def generate(self, real_data, synthetic_data, metadata, verbose=True):
         """Generate report.
 
@@ -134,6 +151,7 @@ class BaseReport:
                 Whether or not to print report summary and progress.
         """
         self._validate(real_data, synthetic_data, metadata)
+        self._skipped_properties = self._get_skipped_properties(metadata)
         self.convert_datetimes(real_data, synthetic_data, metadata)
 
         self.report_info['generated_date'] = datetime.today().strftime('%Y-%m-%d')
@@ -156,14 +174,24 @@ class BaseReport:
 
         start_time = time.time()
         for ind, (property_name, property_instance) in enumerate(self._properties.items()):
+            property_description = f'({ind + 1}/{len(self._properties)}) Evaluating {property_name}'
+            if property_name in self._skipped_properties:
+                property_instance.is_computed = False
+                property_instance.details = pd.DataFrame()
+                if verbose:
+                    sys.stdout.write(
+                        f'{property_description}: N/A\n{self._skipped_property_message}\n\n'
+                    )
+                    sys.stdout.flush()
+
+                continue
+
             if verbose:
                 num_iterations = int(property_instance._get_num_iterations(metadata))
                 progress_bar = tqdm.tqdm(
                     total=num_iterations, file=sys.stdout, bar_format='{desc}|{bar}{r_bar}|'
                 )
-                progress_bar.set_description(
-                    f'({ind + 1}/{len(self._properties)}) Evaluating {property_name}'
-                )
+                progress_bar.set_description(property_description)
 
             if hasattr(self, 'real_correlation_threshold') and hasattr(
                 property_instance, 'real_correlation_threshold'
@@ -180,7 +208,9 @@ class BaseReport:
             )
             scores.append(score)
             if verbose:
-                progress_bar.close()
+                if progress_bar is not None:
+                    progress_bar.close()
+                    progress_bar = None
                 sys.stdout.write(f'{property_name} Score: {round(score * 100, 2)}%\n\n')
                 sys.stdout.flush()
 

sdmetrics-0.28.1.dev0/sdmetrics/reports/base_unified_report.py

@@ -0,0 +1,118 @@
+"""Unified table base report."""
+
+import pandas as pd
+
+from sdmetrics._utils_metadata import _validate_unified_metadata
+from sdmetrics.reports.multi_table.base_multi_table_report import BaseMultiTableReport
+
+
+class BaseUnifiedReport(BaseMultiTableReport):
+    """Base Unified Report for single-table and multi-table data."""
+
+    _SINGLE_TABLE_SKIPPED_PROPERTIES = frozenset({
+        'Relationship Validity',
+        'Cardinality',
+        'Intertable Trends',
+    })
+    _skipped_property_message = 'This property does not apply to single-table data.'
+
+    def _get_skipped_properties(self, metadata):
+        """Return properties unavailable to single-table data.
+
+        Args:
+            metadata (dict):
+                The metadata dict.
+
+        Returns:
+            set[str]:
+                Names of properties to skip.
+        """
+        if len(metadata.get('tables', {})) == 1:
+            return self._SINGLE_TABLE_SKIPPED_PROPERTIES
+
+        return super()._get_skipped_properties(metadata)
+
+    def _validate_data_format(self, real_data, synthetic_data):
+        """Validate that the real and synthetic data have compatible formats.
+
+        Args:
+            real_data (dict[str, pd.DataFrame]):
+                The real data.
+            synthetic_data (dict[str, pd.DataFrame]):
+                The synthetic data.
+        """
+        if not isinstance(real_data, dict):
+            raise ValueError(
+                'Please pass in a dictionary mapping tables to dataframes for real_data.'
+            )
+
+        if not isinstance(synthetic_data, dict):
+            raise ValueError(
+                'Please pass in a dictionary mapping tables to dataframes for synthetic_data.'
+            )
+
+        all_real_dataframes = all(isinstance(table, pd.DataFrame) for table in real_data.values())
+        all_synthetic_dataframes = all(
+            isinstance(table, pd.DataFrame) for table in synthetic_data.values()
+        )
+        if all_real_dataframes and all_synthetic_dataframes:
+            return
+
+        raise ValueError(
+            f'{self.__class__.__name__} expects real_data and synthetic_data to both be '
+            'pandas.DataFrame, or both be dictionaries mapping table names to '
+            f'pandas.DataFrame. Received real_data={type(real_data).__name__} and '
+            f'synthetic_data={type(synthetic_data).__name__}.'
+        )
+
+    def _check_property_single_table(self, property_name):
+        is_single_table = self.report_info.get('num_tables', 0) == 1
+        skipped_properties = getattr(self, '_SINGLE_TABLE_SKIPPED_PROPERTIES', [])
+        if is_single_table and property_name in skipped_properties:
+            raise ValueError('This property is not available for single-table datasets.')
+
+    def _validate_property_generated(self, property_name):
+        super()._validate_property_generated(property_name)
+        self._check_property_single_table(property_name)
+
+    def _validate(self, real_data, synthetic_data, metadata):
+        """Validate the inputs.
+
+        Args:
+            real_data (dict[str, pd.DataFrame]):
+                The real data.
+            synthetic_data (dict[str, pd.DataFrame]):
+                The synthetic data.
+            metadata (dict):
+                The metadata.
+        """
+        _validate_unified_metadata(metadata)
+        self.table_names = list(metadata.get('tables', []))
+        self._validate_data_format(real_data, synthetic_data)
+        self._validate_metadata_matches_data(
+            real_data,
+            synthetic_data,
+            metadata,
+        )
+
+    def get_properties(self):
+        """Return the property score.
+
+        Returns:
+            pandas.DataFrame
+                The property score.
+        """
+        self._check_report_generated()
+        name, score = [], []
+        is_single_table = self.report_info.get('num_tables', 0) == 1
+
+        for property_name, property_instance in self._properties.items():
+            if not (is_single_table and property_name in self._SINGLE_TABLE_SKIPPED_PROPERTIES):
+                property_score = property_instance._compute_average()
+                name.append(property_name)
+                score.append(property_score)
+
+        return pd.DataFrame({
+            'Property': name,
+            'Score': score,
+        })

sdmetrics-0.28.1.dev0/sdmetrics/reports/diagnostic_report.py

@@ -0,0 +1,23 @@
+"""Unified diagnostic report."""
+
+from sdmetrics.reports.base_unified_report import BaseUnifiedReport
+from sdmetrics.reports.multi_table._properties import DataValidity, RelationshipValidity, Structure
+
+
+class DiagnosticReport(BaseUnifiedReport):
+    """Diagnostic report for single-table and multi-table data.
+
+    This class creates a diagnostic report for single-table data.
+    It calculates the quality score using the multi-table report properties.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self._properties = {
+            'Data Validity': DataValidity(),
+            'Data Structure': Structure(),
+            'Relationship Validity': RelationshipValidity(),
+        }
+
+    def _validate_metadata_matches_data(self, real_data, synthetic_data, metadata):
+        self._validate_relationships(real_data, synthetic_data, metadata)

sdmetrics-0.28.1.dev0/sdmetrics/reports/multi_table/__init__.py

@@ -0,0 +1,21 @@
+"""Multi table reports for sdmetrics."""
+
+__all__ = [
+    'QualityReport',  # noqa: F822
+    'DiagnosticReport',  # noqa: F822
+]
+
+
+def __getattr__(name):
+    """Lazy load deprecated report classes."""
+    if name == 'QualityReport':
+        from sdmetrics.reports.multi_table.quality_report import QualityReport
+
+        return QualityReport
+
+    if name == 'DiagnosticReport':
+        from sdmetrics.reports.multi_table.diagnostic_report import DiagnosticReport
+
+        return DiagnosticReport
+
+    raise AttributeError(f"module 'sdmetrics.reports.multi_table' has no attribute '{name}'")

{sdmetrics-0.27.3.dev0 → sdmetrics-0.28.1.dev0}/sdmetrics/reports/multi_table/base_multi_table_report.py

@@ -20,7 +20,7 @@ class BaseMultiTableReport(BaseReport):
         self.table_names = []
 
     def _validate_data_format(self, real_data, synthetic_data):
-        """Validate that the real and synthetic are dictionnaries of tables."""
+        """Validate that the real and synthetic are dictionaries of tables."""
         is_real_dict = isinstance(real_data, dict)
         is_synthetic_dict = isinstance(synthetic_data, dict)
         if is_real_dict and is_synthetic_dict:

{sdmetrics-0.27.3.dev0 → sdmetrics-0.28.1.dev0}/sdmetrics/reports/multi_table/diagnostic_report.py

@@ -2,6 +2,9 @@
 
 from sdmetrics.reports.multi_table._properties import DataValidity, RelationshipValidity, Structure
 from sdmetrics.reports.multi_table.base_multi_table_report import BaseMultiTableReport
+from sdmetrics.reports.utils import _warn_deprecated_report
+
+_warn_deprecated_report('multi table diagnostic', 'DiagnosticReport')
 
 
 class DiagnosticReport(BaseMultiTableReport):

{sdmetrics-0.27.3.dev0 → sdmetrics-0.28.1.dev0}/sdmetrics/reports/multi_table/quality_report.py

@@ -7,6 +7,13 @@ from sdmetrics.reports.multi_table._properties import (
     InterTableTrends,
 )
 from sdmetrics.reports.multi_table.base_multi_table_report import BaseMultiTableReport
+from sdmetrics.reports.utils import (
+    DEFAULT_REAL_ASSOCIATION_THRESHOLD,
+    DEFAULT_REAL_CORRELATION_THRESHOLD,
+    _warn_deprecated_report,
+)
+
+_warn_deprecated_report('multi table quality', 'QualityReport')
 
 
 class QualityReport(BaseMultiTableReport):
@@ -18,8 +25,8 @@ class QualityReport(BaseMultiTableReport):
 
     def __init__(self):
         super().__init__()
-        self.real_correlation_threshold = 0.5
-        self.real_association_threshold = 0.3
+        self.real_correlation_threshold = DEFAULT_REAL_CORRELATION_THRESHOLD
+        self.real_association_threshold = DEFAULT_REAL_ASSOCIATION_THRESHOLD
         self._properties = {
             'Column Shapes': ColumnShapes(),
             'Column Pair Trends': ColumnPairTrends(),