sdmetrics 0.27.2.dev0__tar.gz → 0.27.3.dev0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sdmetrics
-Version: 0.27.2.dev0
+Version: 0.27.3.dev0
 Summary: Metrics for Synthetic Data Generation Projects
 Author-email: MIT Data To AI Lab <dailabmit@gmail.com>
 License-Expression: MIT
@@ -176,10 +176,7 @@ my_report = QualityReport.load(filepath='demo_data_quality_report.pkl')
 # set by the real data
 from sdmetrics.single_column import BoundaryAdherence
 
-BoundaryAdherence.compute(
-    real_data['start_date'],
-    synthetic_data['start_date']
-)
+BoundaryAdherence.compute(real_data['start_date'], synthetic_data['start_date'])
 ```
 ```
 0.8503937007874016
@@ -189,11 +186,7 @@ BoundaryAdherence.compute(
 # calculate whether the synthetic data is new or whether it's an exact copy of the real data
 from sdmetrics.single_table import NewRowSynthesis
 
-NewRowSynthesis.compute(
-    real_data,
-    synthetic_data,
-    metadata
-)
+NewRowSynthesis.compute(real_data, synthetic_data, metadata)
 ```
 ```
 1.0

{sdmetrics-0.27.2.dev0 → sdmetrics-0.27.3.dev0}/README.md

@@ -91,10 +91,7 @@ my_report = QualityReport.load(filepath='demo_data_quality_report.pkl')
 # set by the real data
 from sdmetrics.single_column import BoundaryAdherence
 
-BoundaryAdherence.compute(
-    real_data['start_date'],
-    synthetic_data['start_date']
-)
+BoundaryAdherence.compute(real_data['start_date'], synthetic_data['start_date'])
 ```
 ```
 0.8503937007874016
@@ -104,11 +101,7 @@ BoundaryAdherence.compute(
 # calculate whether the synthetic data is new or whether it's an exact copy of the real data
 from sdmetrics.single_table import NewRowSynthesis
 
-NewRowSynthesis.compute(
-    real_data,
-    synthetic_data,
-    metadata
-)
+NewRowSynthesis.compute(real_data, synthetic_data, metadata)
 ```
 ```
 1.0

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

@@ -148,7 +148,7 @@ convention = 'google'
 add-ignore = ['D107', 'D407', 'D417']
 
 [tool.bumpversion]
-current_version = "0.27.2.dev0"
+current_version = "0.27.3.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.2.dev0 → sdmetrics-0.27.3.dev0}/sdmetrics/__init__.py

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

{sdmetrics-0.27.2.dev0 → sdmetrics-0.27.3.dev0}/sdmetrics/column_pairs/statistical/cardinality_boundary_adherence.py

@@ -33,10 +33,10 @@ class CardinalityBoundaryAdherence(ColumnPairsMetric):
         """Calculate the percentage of synthetic parents with cardinality in the correct range.
 
         Args:
-            real_data (tuple(pd.Series, pd.Series)):
-                A tuple with the real primary key Series as the first element and real
-                foreign keys Series as the second element.
-            synthetic_data (tuple(pd.Series, pd.Series)):
+            real_data (tuple(pd.DataFrame, pd.DataFrame) or tuple(pd.Series, pd.Series)):
+                A tuple with the real primary key DataFrame as the first element and real
+                foreign keys DataFrame as the second element.
+            synthetic_data (tuple(pd.DataFrame, pd.DataFrame) or tuple(pd.Series, pd.Series)):
                 A tuple with the synthetic primary key as the first element and synthetic
                 foreign keys as the second element.
 
@@ -45,10 +45,10 @@ class CardinalityBoundaryAdherence(ColumnPairsMetric):
                 Metric output.
         """
         real_cardinality = pd.DataFrame(index=real_data[0].copy())
-        real_cardinality['cardinality'] = real_data[1].value_counts()
+        real_cardinality['cardinality'] = real_data[1].value_counts(dropna=False)
         real_cardinality = real_cardinality.fillna(0)
         synthetic_cardinality = pd.DataFrame(index=synthetic_data[0].copy())
-        synthetic_cardinality['cardinality'] = synthetic_data[1].value_counts()
+        synthetic_cardinality['cardinality'] = synthetic_data[1].value_counts(dropna=False)
         synthetic_cardinality = synthetic_cardinality.fillna(0)
 
         min_cardinality = real_cardinality['cardinality'].min()
@@ -66,10 +66,10 @@ class CardinalityBoundaryAdherence(ColumnPairsMetric):
         """Calculate the percentage of synthetic parents with cardinality in the correct range.
 
         Args:
-            real_data (tuple(pd.Series, pd.Series)):
-                A tuple with the real primary key Series as the first element and real
-                foreign keys Series as the second element.
-            synthetic_data (tuple(pd.Series, pd.Series)):
+            real_data (tuple(pd.DataFrame, pd.DataFrame) or tuple(pd.Series, pd.Series)):
+                A tuple with the real primary key DataFrame as the first element and real
+                foreign keys DataFrame as the second element.
+            synthetic_data (tuple(pd.DataFrame, pd.DataFrame) or tuple(pd.Series, pd.Series)):
                 A tuple with the synthetic primary key as the first element and synthetic
                 foreign keys as the second element.
 

{sdmetrics-0.27.2.dev0 → sdmetrics-0.27.3.dev0}/sdmetrics/column_pairs/statistical/contingency_similarity.py

@@ -117,7 +117,9 @@ class ContingencySimilarity(ColumnPairsMetric):
         contingency_synthetic = synthetic.groupby(list(columns), dropna=False).size() / len(
             synthetic
         )
-        combined_index = contingency_real.index.union(contingency_synthetic.index, sort=False)
+        combined_index = contingency_real.index.union(
+            contingency_synthetic.index, sort=False
+        ).drop_duplicates()
         contingency_synthetic = contingency_synthetic.reindex(combined_index, fill_value=0)
         contingency_real = contingency_real.reindex(combined_index, fill_value=0)
         diff = abs(contingency_real - contingency_synthetic).fillna(0)

{sdmetrics-0.27.2.dev0 → sdmetrics-0.27.3.dev0}/sdmetrics/column_pairs/statistical/referential_integrity.py

@@ -31,31 +31,60 @@ class ReferentialIntegrity(ColumnPairsMetric):
     goal = Goal.MAXIMIZE
     min_value = 0.0
     max_value = 1.0
+    INDICATOR_NAME = '__ri_indicator__'
+
+    @staticmethod
+    def _create_unique_name(name, list_names):
+        """Modify the ``name`` parameter if it already exists in the list of names."""
+        result = name
+        while result in list_names:
+            result += '_'
+
+        return result
 
     @classmethod
     def compute_breakdown(cls, real_data, synthetic_data):
         """Compute the score breakdown of the referential integrity metric.
 
         Args:
-            real_data (tuple of 2 pandas.Series):
+            real_data (tuple of 2 pandas.DataFrame):
                 (primary_key, foreign_key) columns from the real data.
-            synthetic_data (tuple of 2 pandas.Series):
+            synthetic_data (tuple of 2 pandas.DataFrame):
                 (primary_key, foreign_key) columns from the synthetic data.
 
         Returns:
             dict:
                 The score breakdown of the key uniqueness metric.
         """
-        if pd.isna(real_data[1]).any():
-            synthetic_data = list(synthetic_data)
-            synthetic_data[1] = synthetic_data[1].dropna()
-
-        missing_parents = not real_data[1].isin(real_data[0]).all()
+        real_pk_df, real_fk_df = real_data
+        synth_pk_df, synth_fk_df = synthetic_data
+        pk_columns = list(real_pk_df.columns)
+        fk_columns = list(real_fk_df.columns)
+        indicator_name = cls._create_unique_name(cls.INDICATOR_NAME, pk_columns + fk_columns)
+
+        real_merged = real_fk_df.merge(
+            real_pk_df.drop_duplicates(),
+            how='left',
+            left_on=fk_columns,
+            right_on=pk_columns,
+            indicator=indicator_name,
+        )
+        missing_parents = (real_merged[indicator_name] == 'left_only').any()
         if missing_parents:
             LOGGER.info("The real data has foreign keys that don't reference any primary key.")
 
-        score = synthetic_data[1].isin(synthetic_data[0]).mean()
+        if len(fk_columns) == 1 and pd.isna(real_fk_df[fk_columns[0]]).any():
+            synth_fk_df = synth_fk_df.dropna()
+
+        synth_merged = synth_fk_df.merge(
+            synth_pk_df.drop_duplicates(),
+            how='left',
+            left_on=fk_columns,
+            right_on=pk_columns,
+            indicator=indicator_name,
+        )
 
+        score = (synth_merged[indicator_name] == 'both').mean()
         return {'score': score}
 
     @classmethod
@@ -63,9 +92,9 @@ class ReferentialIntegrity(ColumnPairsMetric):
         """Compute the referential integrity of two columns.
 
         Args:
-            real_data (tuple of 2 pandas.Series):
+            real_data (tuple of 2 pandas.DataFrame):
                 (primary_key, foreign_key) columns from the real data.
-            synthetic_data (tuple of 2 pandas.Series):
+            synthetic_data (tuple of 2 pandas.DataFrame):
                 (primary_key, foreign_key) columns from the synthetic data.
 
         Returns:

{sdmetrics-0.27.2.dev0 → sdmetrics-0.27.3.dev0}/sdmetrics/multi_table/README.md

@@ -91,6 +91,6 @@ For example, we could execute the same metric as before by passing the `metadata
 of having to specify the individual `foreign_keys`:
 
 ```python
-In [10]: LogisticParentChildDetection.compute(real_data, synthetic_data, metadata)
+In[10]: LogisticParentChildDetection.compute(real_data, synthetic_data, metadata)
 Out[10]: 0.7569444444444444
 ```

{sdmetrics-0.27.2.dev0 → sdmetrics-0.27.3.dev0}/sdmetrics/reports/multi_table/_properties/inter_table_trends.py

@@ -11,6 +11,7 @@ from sdmetrics.reports.single_table._properties import (
     ColumnPairTrends as SingleTableColumnPairTrends,
 )
 from sdmetrics.reports.utils import PlotConfig
+from sdmetrics.utils import _cast_to_iterable
 
 
 class InterTableTrends(BaseMultiTableProperty):
@@ -50,16 +51,16 @@ class InterTableTrends(BaseMultiTableProperty):
         """
         parent = relationship['parent_table_name']
         child = relationship['child_table_name']
-        foreign_key = relationship['child_foreign_key']
-        primary_key = relationship['parent_primary_key']
+        foreign_key = _cast_to_iterable(relationship['child_foreign_key'])
+        primary_key = _cast_to_iterable(relationship['parent_primary_key'])
 
         real_parent = real_data[parent].add_prefix(f'{parent}.')
         real_child = real_data[child].add_prefix(f'{child}.')
         synthetic_parent = synthetic_data[parent].add_prefix(f'{parent}.')
         synthetic_child = synthetic_data[child].add_prefix(f'{child}.')
 
-        child_index = f'{child}.{foreign_key}'
-        parent_index = f'{parent}.{primary_key}'
+        child_index = [f'{child}.{key_col}' for key_col in foreign_key]
+        parent_index = [f'{parent}.{key_col}' for key_col in primary_key]
 
         denormalized_real = real_child.merge(
             real_parent, left_on=child_index, right_on=parent_index
@@ -101,7 +102,12 @@ class InterTableTrends(BaseMultiTableProperty):
         merged_metadata['columns'] = {**child_cols, **parent_cols}
         if 'primary_key' in merged_metadata:
             primary_key = merged_metadata['primary_key']
-            merged_metadata['primary_key'] = f'{child_table}.{primary_key}'
+            if isinstance(primary_key, list):
+                merged_metadata['primary_key'] = [
+                    f'{child_table}.{pk_col}' for pk_col in primary_key
+                ]
+            else:
+                merged_metadata['primary_key'] = f'{child_table}.{primary_key}'
 
         return merged_metadata, list(parent_cols.keys()), list(child_cols.keys())
 
@@ -123,6 +129,7 @@ class InterTableTrends(BaseMultiTableProperty):
             parent = relationship['parent_table_name']
             child = relationship['child_table_name']
             foreign_key = relationship['child_foreign_key']
+            fk_tuple = tuple(foreign_key) if isinstance(foreign_key, list) else foreign_key
 
             denormalized_real, denormalized_synthetic = self._denormalize_tables(
                 real_data, synthetic_data, relationship
@@ -132,14 +139,14 @@ class InterTableTrends(BaseMultiTableProperty):
 
             parent_child_pairs = itertools.product(parent_cols, child_cols)
 
-            self._properties[(parent, child, foreign_key)] = SingleTableColumnPairTrends()
+            self._properties[(parent, child, fk_tuple)] = SingleTableColumnPairTrends()
             self._properties[
-                (parent, child, foreign_key)
+                (parent, child, fk_tuple)
             ].real_correlation_threshold = self.real_correlation_threshold
             self._properties[
-                (parent, child, foreign_key)
+                (parent, child, fk_tuple)
             ].real_association_threshold = self.real_association_threshold
-            details = self._properties[(parent, child, foreign_key)]._generate_details(
+            details = self._properties[(parent, child, fk_tuple)]._generate_details(
                 denormalized_real,
                 denormalized_synthetic,
                 merged_metadata,
@@ -149,7 +156,7 @@ class InterTableTrends(BaseMultiTableProperty):
 
             details['Parent Table'] = parent
             details['Child Table'] = child
-            details['Foreign Key'] = foreign_key
+            details['Foreign Key'] = str(foreign_key)
             if not details.empty:
                 details['Column 1'] = details['Column 1'].str.replace(
                     f'{parent}.', '', n=1, regex=False
@@ -233,18 +240,15 @@ class InterTableTrends(BaseMultiTableProperty):
     def get_visualization(self, table_name=None):
         """Create a plot to show the inter table trends data.
 
-        Returns:
-            plotly.graph_objects._figure.Figure
-
         Args:
             table_name (str, optional):
                 Table to plot. Defaults to None.
 
-        Raises:
-            - ``ValueError`` if property has not been computed.
-
         Returns:
             plotly.graph_objects._figure.Figure
+
+        Raises:
+            - ``ValueError`` if property has not been computed.
         """
         if not self.is_computed:
             raise ValueError(

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

@@ -3,6 +3,7 @@
 import pandas as pd
 
 from sdmetrics.reports.base_report import BaseReport
+from sdmetrics.utils import _cast_to_iterable
 from sdmetrics.visualization import set_plotly_config
 
 
@@ -43,22 +44,36 @@ class BaseMultiTableReport(BaseReport):
     def _validate_relationships(self, real_data, synthetic_data, metadata):
         """Validate that the relationships are valid."""
         for rel in metadata.get('relationships', []):
-            parent_dtype = real_data[rel['parent_table_name']][rel['parent_primary_key']].dtype
-            child_dtype = real_data[rel['child_table_name']][rel['child_foreign_key']].dtype
-            if (parent_dtype == 'object' and child_dtype != 'object') or (
-                parent_dtype != 'object' and child_dtype == 'object'
-            ):
-                parent = rel['parent_table_name']
-                parent_key = rel['parent_primary_key']
-                child = rel['child_table_name']
-                child_key = rel['child_foreign_key']
+            parent = rel['parent_table_name']
+            parent_key = rel['parent_primary_key']
+            child = rel['child_table_name']
+            child_key = rel['child_foreign_key']
+            parent_key_str = f"'{parent_key}'" if isinstance(parent_key, str) else str(parent_key)
+            child_key_str = f"'{child_key}'" if isinstance(child_key, str) else str(child_key)
+            parent_primary_key = _cast_to_iterable(parent_key)
+            child_foreign_key = _cast_to_iterable(child_key)
+
+            if len(parent_primary_key) != len(child_foreign_key):
                 error_msg = (
                     f"The '{parent}' table and '{child}' table cannot be merged "
-                    'for computing the cardinality. Please make sure the primary key'
-                    f" in '{parent}' ('{parent_key}') and the foreign key in '{child}'"
-                    f" ('{child_key}') have the same data type."
+                    'for computing the cardinality. Please make sure the number of columns '
+                    f'in the primary key ({parent_key_str}) matches the number of '
+                    f'columns in the foreign key ({child_key_str}).'
                 )
                 raise ValueError(error_msg)
+            parent_dtypes = real_data[rel['parent_table_name']][parent_primary_key].dtypes
+            child_dtypes = real_data[rel['child_table_name']][child_foreign_key].dtypes
+            for parent_dtype, child_dtype in zip(parent_dtypes, child_dtypes):
+                if (parent_dtype == 'object' and child_dtype != 'object') or (
+                    parent_dtype != 'object' and child_dtype == 'object'
+                ):
+                    error_msg = (
+                        f"The '{parent}' table and '{child}' table cannot be merged "
+                        'for computing the cardinality. Please make sure the primary key'
+                        f" in '{parent}' ({parent_key_str}) and the foreign key in '{child}'"
+                        f' ({child_key_str}) have the same data types.'
+                    )
+                    raise ValueError(error_msg)
 
     def _validate_metadata_matches_data(self, real_data, synthetic_data, metadata):
         """Validate that the metadata matches the data."""

{sdmetrics-0.27.2.dev0 → sdmetrics-0.27.3.dev0}/sdmetrics/reports/single_table/_properties/data_validity.py

@@ -39,13 +39,19 @@ class DataValidity(BaseSingleTableProperty):
                 The progress bar to use. Defaults to None.
         """
         column_names, metric_names, scores = [], [], []
+        column_sdtypes = [(col, metadata['columns'][col]['sdtype']) for col in metadata['columns']]
         error_messages = []
         primary_key = metadata.get('primary_key')
+        if isinstance(primary_key, list):
+            if len(primary_key) > 1:
+                column_sdtypes = [(primary_key, None)] + column_sdtypes
+            else:
+                primary_key = primary_key[0]
+
         alternate_keys = metadata.get('alternate_keys', [])
         sequence_index = metadata.get('sequence_index')
 
-        for column_name in metadata['columns']:
-            sdtype = metadata['columns'][column_name]['sdtype']
+        for column_name, sdtype in column_sdtypes:
             primary_key_match = column_name == primary_key
             alternate_key_match = column_name in alternate_keys
             is_unique = primary_key_match or alternate_key_match

{sdmetrics-0.27.2.dev0 → sdmetrics-0.27.3.dev0}/sdmetrics/single_column/statistical/key_uniqueness.py

@@ -2,6 +2,8 @@
 
 import logging
 
+import pandas as pd
+
 from sdmetrics.goal import Goal
 from sdmetrics.single_column.base import SingleColumnMetric
 
@@ -34,21 +36,27 @@ class KeyUniqueness(SingleColumnMetric):
         """Compute the score breakdown of the key uniqueness metric.
 
         Args:
-            real_data (pandas.Series):
-                The real data.
-            synthetic_data (pandas.Series):
-                The synthetic data.
+            real_data (pandas.DataFrame or pd.Series):
+                The real data key.
+            synthetic_data (pandas.DataFrame or pd.Series):
+                The synthetic data key.
 
         Returns:
             dict:
                 The score breakdown of the key uniqueness metric.
         """
+        if isinstance(real_data, pd.Series):
+            real_data = real_data.to_frame()
+        if isinstance(synthetic_data, pd.Series):
+            synthetic_data = synthetic_data.to_frame()
+
         has_duplicates = real_data.duplicated().any()
-        has_nans = real_data.isna().any()
+        has_nans = real_data.isna().all(axis=1).any()
         if has_duplicates or has_nans:
             LOGGER.info('The real data contains NA or duplicate values.')
 
-        nans_or_duplicates_synthetic = synthetic_data.duplicated() | synthetic_data.isna()
+        is_nan_synthetic = synthetic_data.isna().all(axis=1)
+        nans_or_duplicates_synthetic = synthetic_data.duplicated() | is_nan_synthetic
         score = 1 - nans_or_duplicates_synthetic.sum() / len(synthetic_data)
 
         return {'score': score}
@@ -58,10 +66,10 @@ class KeyUniqueness(SingleColumnMetric):
         """Compute the key uniqueness metric.
 
         Args:
-            real_data (pandas.Series):
-                The real data.
-            synthetic_data (pandas.Series):
-                The synthetic data.
+            real_data (pd.DataFrame or pd.Series):
+                The real data key.
+            synthetic_data (pd.DataFrame or pd.Series):
+                The synthetic data key.
 
         Returns:
             float:

{sdmetrics-0.27.2.dev0 → sdmetrics-0.27.3.dev0}/sdmetrics/single_table/README.md

@@ -172,10 +172,12 @@ For example, we could execute the same metric as before by adding the `target` e
 metadata dict:
 
 ```python
-In [11]: users_metadata = metadata['tables']['users'].copy()
+In[11]: users_metadata = metadata['tables']['users'].copy()
 
-In [12]: users_metadata['target'] = 'country'
+In[12]: users_metadata['target'] = 'country'
 
-In [13]: MulticlassDecisionTreeClassifier.compute(real_table, synthetic_table, metadata=users_metadata)
+In[13]: MulticlassDecisionTreeClassifier.compute(
+    real_table, synthetic_table, metadata=users_metadata
+)
 Out[13]: (0.05555555555555555,)
 ```

{sdmetrics-0.27.2.dev0 → sdmetrics-0.27.3.dev0}/sdmetrics/timeseries/README.md

@@ -68,8 +68,8 @@ For example, we could execute the same metric as before by adding the `target` e
 metadata dict:
 
 ```python
-In [7]: metadata['sequence_key'] = 'store_id'
+In[7]: metadata['sequence_key'] = 'store_id'
 
-In [8]: LSTMDetection.compute(real_data, synthetic_data, metadata=metadata)
+In[8]: LSTMDetection.compute(real_data, synthetic_data, metadata=metadata)
 Out[8]: 0.5
 ```

{sdmetrics-0.27.2.dev0 → sdmetrics-0.27.3.dev0}/sdmetrics/utils.py

@@ -90,17 +90,22 @@ def get_cardinality_distribution(parent_column, child_column):
     """Compute the cardinality distribution of the (parent, child) pairing.
 
     Args:
-        parent_column (pandas.Series):
-            The parent column.
-        child_column (pandas.Series):
-            The child column.
+        parent_column (pd.Series or pd.DataFrame):
+            The parent column(s).
+        child_column (pd.Series or pd.DataFrame):
+            The child column(s).
 
     Returns:
-        pandas.Series:
+        pd.Series:
             The cardinality distribution.
     """
-    child_df = pd.DataFrame({'child_counts': child_column.value_counts()})
-    cardinality_df = pd.DataFrame({'parent': parent_column}).join(child_df, on='parent').fillna(0)
+    child_df = pd.DataFrame({'child_counts': child_column.value_counts(dropna=False)})
+    parent_df = (
+        pd.DataFrame({'parent': parent_column})
+        if isinstance(parent_column, pd.Series)
+        else parent_column
+    )
+    cardinality_df = parent_df.join(child_df, on=list(parent_df.columns)).fillna(0)
 
     return cardinality_df['child_counts']
 
@@ -316,3 +321,11 @@ def strip_characters(list_character, a_string):
             result = result.replace(character, '')
 
     return result
+
+
+def _cast_to_iterable(value):
+    """Return a ``list`` if the input object is not a ``list`` or ``tuple``."""
+    if isinstance(value, (list, tuple)):
+        return value
+
+    return [value]

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sdmetrics
-Version: 0.27.2.dev0
+Version: 0.27.3.dev0
 Summary: Metrics for Synthetic Data Generation Projects
 Author-email: MIT Data To AI Lab <dailabmit@gmail.com>
 License-Expression: MIT
@@ -176,10 +176,7 @@ my_report = QualityReport.load(filepath='demo_data_quality_report.pkl')
 # set by the real data
 from sdmetrics.single_column import BoundaryAdherence
 
-BoundaryAdherence.compute(
-    real_data['start_date'],
-    synthetic_data['start_date']
-)
+BoundaryAdherence.compute(real_data['start_date'], synthetic_data['start_date'])
 ```
 ```
 0.8503937007874016
@@ -189,11 +186,7 @@ BoundaryAdherence.compute(
 # calculate whether the synthetic data is new or whether it's an exact copy of the real data
 from sdmetrics.single_table import NewRowSynthesis
 
-NewRowSynthesis.compute(
-    real_data,
-    synthetic_data,
-    metadata
-)
+NewRowSynthesis.compute(real_data, synthetic_data, metadata)
 ```
 ```
 1.0