Remove handling_strategy parameter

docs/developer_guides/sdv/constraints.rst

@@ -27,21 +27,6 @@ The following public methods are implemented in this class:
 * ``from_dict``: Build a ``Constraint`` from its dict representation.
 * ``to_dict``: Return a dict representing the ``Constraint``.
 
-handling_strategy
-~~~~~~~~~~~~~~~~~
-
-Additionally, the ``Constraint.__init__`` method sets up the class based on the value of the
-argument ``handling_strategy`` as follows:
-
-* If ``handling_strategy`` equals ``'transform'``, the ``filter_valid`` method is disabled by
-  replacing it with an identity function.
-* If ``handling_strategy`` equals ``'reject_sampling'``, both the ``transform`` and
-  ``reverse_transform`` methods are disabled by replacing them with an identity function.
-
-Because of this, any subclass has the option to implement both the transformation and reject
-sampling strategies and later on give the user the choice to choose between the two by just
-calling the ``super().__init__`` method passing the corresponding ``handling_strategy`` value.
-
 Implementing a Custom Constraint
 --------------------------------
 
@@ -131,23 +116,13 @@ modeling and sampling the number of `pairs of legs` instead of the number of `le
             table_data[self._column_name] = table_data[self._column_name] * 2
             return table_data
 
-With this new implementation, our Constraint would be ready to handle both strategies,
-`reject sampling` and `transform`, but in some cases we might want to let the user
-chose only one of them, so the other is skipped.
-
-In a situation like this, we can simply add a ``handling_strategy`` parameter to our
-``__init__`` method and call ``super().__init__`` passing it, so the base ``Constraint`` class
-can handle it adequately:
-
-
 .. code-block:: python
 
     class PositiveEven(Constraint):
         """Ensure that values are positive and even."""
 
-        def __init__(self, column_name, handling_strategy='transform'):
+        def __init__(self, column_name):
             self._column_name = column_name
-            super().__init__(handling_strategy=handling_strategy)
 
         def is_valid(self, table_data):
             """Say if values are positive and even."""

docs/user_guides/single_table/handling_constraints.rst

@@ -123,10 +123,7 @@ order to use this constraint we will need to import it from the
 
     from sdv.constraints import FixedCombinations
 
-    fixed_company_department_constraint = FixedCombinations(
-        column_names=['company', 'department'],
-        handling_strategy='transform'
-    )
+    fixed_company_department_constraint = FixedCombinations(column_names=['company', 'department'])
 
 Inequality and ScalarInequality Constraints
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

sdv/constraints/base.py

@@ -4,6 +4,7 @@
 import importlib
 import inspect
 import logging
+import warnings
 
 import pandas as pd
 from copulas.multivariate.gaussian import GaussianMultivariate
@@ -91,61 +92,22 @@ class Constraint(metaclass=ConstraintMeta):
     This class is not intended to be used directly and should rather be
     subclassed to create different types of constraints.
 
-    If ``handling_strategy`` is passed with the value ``transform``
-    or ``reject_sampling``, the ``filter_valid`` or ``transform`` and
-    ``reverse_transform`` methods will be replaced respectively by a simple
-    identity function.
-
     Attributes:
         constraint_columns (tuple[str]):
             The names of the columns used by this constraint.
         rebuild_columns (tuple[str]):
             The names of the columns that this constraint will rebuild during
             ``reverse_transform``.
-    Args:
-        handling_strategy (str):
-            How this Constraint should be handled, which can be ``transform``,
-            ``reject_sampling`` or ``all``.
     """
 
     constraint_columns = ()
     rebuild_columns = ()
     _hyper_transformer = None
+    _use_reject_sampling = False
+    is_custom = False
 
-    def _identity(self, table_data):
-        return table_data
-
-    def _identity_with_validation(self, table_data):
-        self._validate_data_on_constraint(table_data)
-        return table_data
-
-    def __init__(self, handling_strategy):
-        if handling_strategy == 'transform':
-            self.filter_valid = self._identity
-        elif handling_strategy == 'reject_sampling':
-            self.rebuild_columns = ()
-            self.transform = self._identity_with_validation
-            self.reverse_transform = self._identity
-        elif handling_strategy != 'all':
-            raise ValueError('Unknown handling strategy: {}'.format(handling_strategy))
-
-    def _fit(self, table_data):
-        del table_data
-
-    def fit(self, table_data):
-        """Fit ``Constraint`` class to data.
-
-        Args:
-            table_data (pandas.DataFrame):
-                Table data.
-        """
-        self._fit(table_data)
-
-    def _transform(self, table_data):
-        return table_data
-
-    def _validate_data_on_constraint(self, table_data):
-        """Make sure the given data is valid for the given constraints.
+    def _validate_data_meets_constraint(self, table_data):
+        """Make sure the given data is valid for the constraint.
 
         Args:
             data (pandas.DataFrame):
@@ -169,16 +131,37 @@ def _validate_data_on_constraint(self, table_data):
 
                 raise ConstraintsNotMetError(err_msg)
 
-    def check_missing_columns(self, table_data):
-        """Check ``table_data`` for missing columns.
+    def _fit(self, table_data):
+        del table_data
+
+    def fit(self, table_data):
+        """Fit ``Constraint`` class to data.
+
+        Args:
+            table_data (pandas.DataFrame):
+                Table data.
+        """
+        self._fit(table_data)
+        self._validate_data_meets_constraint(table_data)
+
+    def _transform(self, table_data):
+        return table_data
+
+    def _validate_all_columns_present(self, table_data):
+        """Validate that all required columns are in ``table_data``.
 
         Args:
             table_data (pandas.DataFrame):
                 Table data.
+
+        Raises:
+            MissingConstraintColumnError:
+                If the data is missing any columns needed for the constraint transformation,
+                a ``MissingConstraintColumnError`` is raised.
         """
         missing_columns = [col for col in self.constraint_columns if col not in table_data.columns]
         if missing_columns:
-            raise MissingConstraintColumnError()
+            raise MissingConstraintColumnError(missing_columns=missing_columns)
 
     def transform(self, table_data):
         """Perform necessary transformations needed by constraint.
@@ -188,7 +171,8 @@ def transform(self, table_data):
         should overwrite the ``_transform`` method instead. This method raises a
         ``MissingConstraintColumnError`` if the ``table_data`` is missing any columns
         needed to do the transformation. If columns are present, this method will call
-        the ``_transform`` method.
+        the ``_transform`` method. If ``_transform`` fails, the data will be returned
+        unchanged.
 
         Args:
             table_data (pandas.DataFrame):
@@ -198,9 +182,22 @@ def transform(self, table_data):
             pandas.DataFrame:
                 Input data unmodified.
         """
-        self._validate_data_on_constraint(table_data)
-        self.check_missing_columns(table_data)
-        return self._transform(table_data)
+        self._use_reject_sampling = False
+        self._validate_all_columns_present(table_data)
+
+        try:
+            transformed = self._transform(table_data)
+            if self.is_custom:
+                self.reverse_transform(transformed)
+            return transformed
+
+        except Exception:
+            warnings.warn(
+                f'Error transforming {self.__class__.__name__}. Using the reject sampling '
+                'approach instead.'
+            )
+            self._use_reject_sampling = True
+            return table_data
 
     def fit_transform(self, table_data):
         """Fit this Constraint to the data and then transform it.
@@ -216,8 +213,15 @@ def fit_transform(self, table_data):
         self.fit(table_data)
         return self.transform(table_data)
 
+    def _reverse_transform(self, table_data):
+        return table_data
+
     def reverse_transform(self, table_data):
-        """Identity method for completion. To be optionally overwritten by subclasses.
+        """Handle logic around reverse transforming constraints.
+
+        If the ``transform`` method was skipped, then this method should be too.
+        Otherwise attempt to reverse transform and if that fails, return the data
+        unchanged to fall back on reject sampling.
 
         Args:
             table_data (pandas.DataFrame):
@@ -227,7 +231,10 @@ def reverse_transform(self, table_data):
             pandas.DataFrame:
                 Input data unmodified.
         """
-        return table_data
+        if self._use_reject_sampling:
+            return table_data
+
+        return self._reverse_transform(table_data)
 
     def is_valid(self, table_data):
         """Say whether the given table rows are valid.

sdv/constraints/errors.py

@@ -4,6 +4,9 @@
 class MissingConstraintColumnError(Exception):
     """Error to use when constraint is provided a table with missing columns."""
 
+    def __init__(self, missing_columns):
+        self.missing_columns = missing_columns
+
 
 class MultipleConstraintsErrors(Exception):
     """Error used to represent a list of constraint errors."""