CustomConstraint([columns, transform, …])
CustomConstraint
Custom Constraint Class.
CustomConstraint.fit(table_data)
CustomConstraint.fit
Fit Constraint class to data.
Constraint
CustomConstraint.transform(table_data)
CustomConstraint.transform
Perform necessary transformations needed by constraint.
CustomConstraint.fit_transform(table_data)
CustomConstraint.fit_transform
Fit this Constraint to the data and then transform it.
CustomConstraint.reverse_transform(table_data)
CustomConstraint.reverse_transform
Identity method for completion.
CustomConstraint.is_valid(table_data)
CustomConstraint.is_valid
Say whether the given table rows are valid.
CustomConstraint.filter_valid(table_data)
CustomConstraint.filter_valid
Get only the rows that are valid.
CustomConstraint.from_dict(constraint_dict)
CustomConstraint.from_dict
Build a Constraint object from a dict.
CustomConstraint.to_dict()
CustomConstraint.to_dict
Return a dict representation of this Constraint.
FixedCombinations(column_names[, …])
FixedCombinations
Ensure that the combinations across multiple colums are fixed.
FixedCombinations.fit(table_data)
FixedCombinations.fit
FixedCombinations.transform(table_data)
FixedCombinations.transform
FixedCombinations.fit_transform(table_data)
FixedCombinations.fit_transform
FixedCombinations.reverse_transform(table_data)
FixedCombinations.reverse_transform
Reverse transform the table data.
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
FixedCombinations.from_dict(constraint_dict)
FixedCombinations.from_dict
FixedCombinations.to_dict()
FixedCombinations.to_dict
GreaterThan(low, high[, strict, …])
GreaterThan
Ensure that the high column is always greater than the low one.
high
low
GreaterThan.fit(table_data)
GreaterThan.fit
GreaterThan.transform(table_data)
GreaterThan.transform
GreaterThan.fit_transform(table_data)
GreaterThan.fit_transform
GreaterThan.reverse_transform(table_data)
GreaterThan.reverse_transform
GreaterThan.is_valid(table_data)
GreaterThan.is_valid
Say whether high is greater than low in each row.
GreaterThan.filter_valid(table_data)
GreaterThan.filter_valid
GreaterThan.from_dict(constraint_dict)
GreaterThan.from_dict
GreaterThan.to_dict()
GreaterThan.to_dict
Positive(columns[, strict, …])
Positive
Ensure that the given column(s) are always positive.
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(columns[, 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
ColumnFormula(column, formula[, …])
ColumnFormula
Compute a column based on applying a formula on the others.
ColumnFormula.fit(table_data)
ColumnFormula.fit
ColumnFormula.transform(table_data)
ColumnFormula.transform
ColumnFormula.fit_transform(table_data)
ColumnFormula.fit_transform
ColumnFormula.reverse_transform(table_data)
ColumnFormula.reverse_transform
ColumnFormula.is_valid(table_data)
ColumnFormula.is_valid
Say whether the data fulfills the formula.
ColumnFormula.filter_valid(table_data)
ColumnFormula.filter_valid
ColumnFormula.from_dict(constraint_dict)
ColumnFormula.from_dict
ColumnFormula.to_dict()
ColumnFormula.to_dict
Between(column, low, high[, strict, …])
Between
Ensure that the constraint_column is always between high and low.
constraint_column
Between.fit(table_data)
Between.fit
Between.transform(table_data)
Between.transform
Between.fit_transform(table_data)
Between.fit_transform
Between.reverse_transform(table_data)
Between.reverse_transform
Between.is_valid(table_data)
Between.is_valid
Say whether the constraint_column is between the low and high values.
Between.filter_valid(table_data)
Between.filter_valid
Between.from_dict(constraint_dict)
Between.from_dict
Between.to_dict()
Between.to_dict
Rounding(columns, digits[, …])
Rounding
Round a column based on the specified number of digits.
Rounding.fit(table_data)
Rounding.fit
Rounding.transform(table_data)
Rounding.transform
Rounding.fit_transform(table_data)
Rounding.fit_transform
Rounding.reverse_transform(table_data)
Rounding.reverse_transform
Rounding.is_valid(table_data)
Rounding.is_valid
Determine if the data satisfies the rounding constraint.
Rounding.filter_valid(table_data)
Rounding.filter_valid
Rounding.from_dict(constraint_dict)
Rounding.from_dict
Rounding.to_dict()
Rounding.to_dict
OneHotEncoding(columns[, handling_strategy])
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(columns)
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