Danger You are looking at the documentation for an older version of the SDV! We are no longer supporting or maintaining this version of the software Click here to go to the new docs pages.
Danger
You are looking at the documentation for an older version of the SDV! We are no longer supporting or maintaining this version of the software
Click here to go to the new docs pages.
FixedCombinations(column_names)
FixedCombinations
Ensure that the combinations across multiple columns are fixed.
FixedCombinations.fit(table_data)
FixedCombinations.fit
Fit Constraint class to data.
Constraint
FixedCombinations.transform(table_data)
FixedCombinations.transform
Perform necessary transformations needed by constraint.
FixedCombinations.fit_transform(table_data)
FixedCombinations.fit_transform
Fit this Constraint to the data and then transform it.
FixedCombinations.reverse_transform(table_data)
FixedCombinations.reverse_transform
Handle logic around reverse transforming constraints.
FixedCombinations.is_valid(table_data)
FixedCombinations.is_valid
Say whether the column values are within the original combinations.
FixedCombinations.filter_valid(table_data)
FixedCombinations.filter_valid
Get only the rows that are valid.
FixedCombinations.from_dict(constraint_dict)
FixedCombinations.from_dict
Build a Constraint object from a dict.
FixedCombinations.to_dict()
FixedCombinations.to_dict
Return a dict representation of this Constraint.
Inequality(low_column_name, high_column_name)
Inequality
Ensure that the high_column_name column is greater than the low_column_name one.
high_column_name
low_column_name
Inequality.fit(table_data)
Inequality.fit
Inequality.transform(table_data)
Inequality.transform
Inequality.fit_transform(table_data)
Inequality.fit_transform
Inequality.reverse_transform(table_data)
Inequality.reverse_transform
Inequality.is_valid(table_data)
Inequality.is_valid
Check whether high is greater than low in each row.
high
low
Inequality.filter_valid(table_data)
Inequality.filter_valid
Inequality.from_dict(constraint_dict)
Inequality.from_dict
Inequality.to_dict()
Inequality.to_dict
ScalarInequality(column_name, relation, value)
ScalarInequality
Ensure an inequality between the column_name column and a scalar value.
column_name
value
ScalarInequality.fit(table_data)
ScalarInequality.fit
ScalarInequality.transform(table_data)
ScalarInequality.transform
ScalarInequality.fit_transform(table_data)
ScalarInequality.fit_transform
ScalarInequality.reverse_transform(table_data)
ScalarInequality.reverse_transform
ScalarInequality.is_valid(table_data)
ScalarInequality.is_valid
Say whether high is greater than low in each row.
ScalarInequality.filter_valid(table_data)
ScalarInequality.filter_valid
ScalarInequality.from_dict(constraint_dict)
ScalarInequality.from_dict
ScalarInequality.to_dict()
ScalarInequality.to_dict
Positive(column_name[, strict])
Positive
Ensure the column_name column is greater than zero.
Positive.fit(table_data)
Positive.fit
Positive.transform(table_data)
Positive.transform
Positive.fit_transform(table_data)
Positive.fit_transform
Positive.reverse_transform(table_data)
Positive.reverse_transform
Positive.is_valid(table_data)
Positive.is_valid
Positive.filter_valid(table_data)
Positive.filter_valid
Positive.from_dict(constraint_dict)
Positive.from_dict
Positive.to_dict()
Positive.to_dict
Negative(column_name[, strict])
Negative
Ensure that the given columns are always negative.
Negative.fit(table_data)
Negative.fit
Negative.transform(table_data)
Negative.transform
Negative.fit_transform(table_data)
Negative.fit_transform
Negative.reverse_transform(table_data)
Negative.reverse_transform
Negative.is_valid(table_data)
Negative.is_valid
Negative.filter_valid(table_data)
Negative.filter_valid
Negative.from_dict(constraint_dict)
Negative.from_dict
Negative.to_dict()
Negative.to_dict
Range(low_column_name, middle_column_name, …)
Range
Ensure that the middle_column_name is between low and high columns.
middle_column_name
Range.fit(table_data)
Range.fit
Range.transform(table_data)
Range.transform
Range.fit_transform(table_data)
Range.fit_transform
Range.reverse_transform(table_data)
Range.reverse_transform
Range.is_valid(table_data)
Range.is_valid
Say whether the constraint_column is between the low and high values.
constraint_column
Range.filter_valid(table_data)
Range.filter_valid
Range.from_dict(constraint_dict)
Range.from_dict
Range.to_dict()
Range.to_dict
ScalarRange(column_name, low_value, high_value)
ScalarRange
Ensure that the column_name is between the range of low and high.
ScalarRange.fit(table_data)
ScalarRange.fit
ScalarRange.transform(table_data)
ScalarRange.transform
ScalarRange.fit_transform(table_data)
ScalarRange.fit_transform
ScalarRange.reverse_transform(table_data)
ScalarRange.reverse_transform
ScalarRange.is_valid(table_data)
ScalarRange.is_valid
Say whether the column_name is between the low and high values.
ScalarRange.filter_valid(table_data)
ScalarRange.filter_valid
ScalarRange.from_dict(constraint_dict)
ScalarRange.from_dict
ScalarRange.to_dict()
ScalarRange.to_dict
OneHotEncoding(column_names)
OneHotEncoding
Ensure the appropriate columns are one hot encoded.
OneHotEncoding.fit(table_data)
OneHotEncoding.fit
OneHotEncoding.transform(table_data)
OneHotEncoding.transform
OneHotEncoding.fit_transform(table_data)
OneHotEncoding.fit_transform
OneHotEncoding.reverse_transform(table_data)
OneHotEncoding.reverse_transform
OneHotEncoding.is_valid(table_data)
OneHotEncoding.is_valid
Check whether the data satisfies the one-hot constraint.
OneHotEncoding.filter_valid(table_data)
OneHotEncoding.filter_valid
OneHotEncoding.from_dict(constraint_dict)
OneHotEncoding.from_dict
OneHotEncoding.to_dict()
OneHotEncoding.to_dict
Unique(column_names)
Unique
Ensure that each value for a specified column/group of columns is unique.
Unique.fit(table_data)
Unique.fit
Unique.transform(table_data)
Unique.transform
Unique.fit_transform(table_data)
Unique.fit_transform
Unique.reverse_transform(table_data)
Unique.reverse_transform
Unique.is_valid(table_data)
Unique.is_valid
Get indices of first instance of unique rows.
Unique.filter_valid(table_data)
Unique.filter_valid
Unique.from_dict(constraint_dict)
Unique.from_dict
Unique.to_dict()
Unique.to_dict