Tabular Constraints

FixedCombinations

FixedCombinations(column_names)	Ensure that the combinations across multiple columns are fixed.
FixedCombinations.fit(table_data)	Fit Constraint class to data.
FixedCombinations.transform(table_data)	Perform necessary transformations needed by constraint.
FixedCombinations.fit_transform(table_data)	Fit this Constraint to the data and then transform it.
FixedCombinations.reverse_transform(table_data)	Handle logic around reverse transforming constraints.
FixedCombinations.is_valid(table_data)	Say whether the column values are within the original combinations.
FixedCombinations.filter_valid(table_data)	Get only the rows that are valid.
FixedCombinations.from_dict(constraint_dict)	Build a Constraint object from a dict.
FixedCombinations.to_dict()	Return a dict representation of this Constraint.

Inequality

Inequality(low_column_name, high_column_name)	Ensure that the high_column_name column is greater than the low_column_name one.
Inequality.fit(table_data)	Fit Constraint class to data.
Inequality.transform(table_data)	Perform necessary transformations needed by constraint.
Inequality.fit_transform(table_data)	Fit this Constraint to the data and then transform it.
Inequality.reverse_transform(table_data)	Handle logic around reverse transforming constraints.
Inequality.is_valid(table_data)	Check whether high is greater than low in each row.
Inequality.filter_valid(table_data)	Get only the rows that are valid.
Inequality.from_dict(constraint_dict)	Build a Constraint object from a dict.
Inequality.to_dict()	Return a dict representation of this Constraint.

ScalarInequality

ScalarInequality(column_name, relation, value)	Ensure an inequality between the column_name column and a scalar value.
ScalarInequality.fit(table_data)	Fit Constraint class to data.
ScalarInequality.transform(table_data)	Perform necessary transformations needed by constraint.
ScalarInequality.fit_transform(table_data)	Fit this Constraint to the data and then transform it.
ScalarInequality.reverse_transform(table_data)	Handle logic around reverse transforming constraints.
ScalarInequality.is_valid(table_data)	Say whether high is greater than low in each row.
ScalarInequality.filter_valid(table_data)	Get only the rows that are valid.
ScalarInequality.from_dict(constraint_dict)	Build a Constraint object from a dict.
ScalarInequality.to_dict()	Return a dict representation of this Constraint.

Positive

Positive(column_name[, strict])	Ensure the column_name column is greater than zero.
Positive.fit(table_data)	Fit Constraint class to data.
Positive.transform(table_data)	Perform necessary transformations needed by constraint.
Positive.fit_transform(table_data)	Fit this Constraint to the data and then transform it.
Positive.reverse_transform(table_data)	Handle logic around reverse transforming constraints.
Positive.is_valid(table_data)	Say whether high is greater than low in each row.
Positive.filter_valid(table_data)	Get only the rows that are valid.
Positive.from_dict(constraint_dict)	Build a Constraint object from a dict.
Positive.to_dict()	Return a dict representation of this Constraint.

Negative

Negative(column_name[, strict])	Ensure that the given columns are always negative.
Negative.fit(table_data)	Fit Constraint class to data.
Negative.transform(table_data)	Perform necessary transformations needed by constraint.
Negative.fit_transform(table_data)	Fit this Constraint to the data and then transform it.
Negative.reverse_transform(table_data)	Handle logic around reverse transforming constraints.
Negative.is_valid(table_data)	Say whether high is greater than low in each row.
Negative.filter_valid(table_data)	Get only the rows that are valid.
Negative.from_dict(constraint_dict)	Build a Constraint object from a dict.
Negative.to_dict()	Return a dict representation of this Constraint.

Range

Range(low_column_name, middle_column_name, …)	Ensure that the middle_column_name is between low and high columns.
Range.fit(table_data)	Fit Constraint class to data.
Range.transform(table_data)	Perform necessary transformations needed by constraint.
Range.fit_transform(table_data)	Fit this Constraint to the data and then transform it.
Range.reverse_transform(table_data)	Handle logic around reverse transforming constraints.
Range.is_valid(table_data)	Say whether the constraint_column is between the low and high values.
Range.filter_valid(table_data)	Get only the rows that are valid.
Range.from_dict(constraint_dict)	Build a Constraint object from a dict.
Range.to_dict()	Return a dict representation of this Constraint.

ScalarRange

ScalarRange(column_name, low_value, high_value)	Ensure that the column_name is between the range of low and high.
ScalarRange.fit(table_data)	Fit Constraint class to data.
ScalarRange.transform(table_data)	Perform necessary transformations needed by constraint.
ScalarRange.fit_transform(table_data)	Fit this Constraint to the data and then transform it.
ScalarRange.reverse_transform(table_data)	Handle logic around reverse transforming constraints.
ScalarRange.is_valid(table_data)	Say whether the column_name is between the low and high values.
ScalarRange.filter_valid(table_data)	Get only the rows that are valid.
ScalarRange.from_dict(constraint_dict)	Build a Constraint object from a dict.
ScalarRange.to_dict()	Return a dict representation of this Constraint.

OneHotEncoding

OneHotEncoding(column_names)	Ensure the appropriate columns are one hot encoded.
OneHotEncoding.fit(table_data)	Fit Constraint class to data.
OneHotEncoding.transform(table_data)	Perform necessary transformations needed by constraint.
OneHotEncoding.fit_transform(table_data)	Fit this Constraint to the data and then transform it.
OneHotEncoding.reverse_transform(table_data)	Handle logic around reverse transforming constraints.
OneHotEncoding.is_valid(table_data)	Check whether the data satisfies the one-hot constraint.
OneHotEncoding.filter_valid(table_data)	Get only the rows that are valid.
OneHotEncoding.from_dict(constraint_dict)	Build a Constraint object from a dict.
OneHotEncoding.to_dict()	Return a dict representation of this Constraint.

Unique

Unique(column_names)	Ensure that each value for a specified column/group of columns is unique.
Unique.fit(table_data)	Fit Constraint class to data.
Unique.transform(table_data)	Perform necessary transformations needed by constraint.
Unique.fit_transform(table_data)	Fit this Constraint to the data and then transform it.
Unique.reverse_transform(table_data)	Handle logic around reverse transforming constraints.
Unique.is_valid(table_data)	Get indices of first instance of unique rows.
Unique.filter_valid(table_data)	Get only the rows that are valid.
Unique.from_dict(constraint_dict)	Build a Constraint object from a dict.
Unique.to_dict()	Return a dict representation of this Constraint.

sdv.constraints.Constraint.to_dict sdv.constraints.FixedCombinations