Tabular Constraints

CustomConstraint

CustomConstraint([transform, …])

Custom Constraint Class.

CustomConstraint.fit(table_data)

Fit Constraint class to data.

CustomConstraint.transform(table_data)

Perform necessary transformations needed by constraint.

CustomConstraint.fit_transform(table_data)

Fit this Constraint to the data and then transform it.

CustomConstraint.reverse_transform(table_data)

Identity method for completion.

CustomConstraint.is_valid(table_data)

Say whether the given table rows are valid.

CustomConstraint.filter_valid(table_data)

Get only the rows that are valid.

CustomConstraint.from_dict(constraint_dict)

Build a Constraint object from a dict.

CustomConstraint.to_dict()

Return a dict representation of this Constraint.

UniqueCombinations

UniqueCombinations(columns[, …])

Ensure that the combinations across multiple colums stay unique.

UniqueCombinations.fit(table_data)

Fit Constraint class to data.

UniqueCombinations.transform(table_data)

Perform necessary transformations needed by constraint.

UniqueCombinations.fit_transform(table_data)

Fit this Constraint to the data and then transform it.

UniqueCombinations.reverse_transform(table_data)

Reverse transform the table data.

UniqueCombinations.is_valid(table_data)

Say whether the column values are within the original combinations.

UniqueCombinations.filter_valid(table_data)

Get only the rows that are valid.

UniqueCombinations.from_dict(constraint_dict)

Build a Constraint object from a dict.

UniqueCombinations.to_dict()

Return a dict representation of this Constraint.

GreaterThan

GreaterThan(low, high[, strict, …])

Ensure that the high column is always greater than the low one.

GreaterThan.fit(table_data)

Fit Constraint class to data.

GreaterThan.transform(table_data)

Perform necessary transformations needed by constraint.

GreaterThan.fit_transform(table_data)

Fit this Constraint to the data and then transform it.

GreaterThan.reverse_transform(table_data)

Reverse transform the table data.

GreaterThan.is_valid(table_data)

Say whether high is greater than low in each row.

GreaterThan.filter_valid(table_data)

Get only the rows that are valid.

GreaterThan.from_dict(constraint_dict)

Build a Constraint object from a dict.

GreaterThan.to_dict()

Return a dict representation of this Constraint.

Positive

Positive(high[, strict, handling_strategy, …])

Ensure that the high column is always positive.

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)

Reverse transform the table data.

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(low[, strict, handling_strategy, …])

Ensure that the low column is 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)

Reverse transform the table data.

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.

ColumnFormula

ColumnFormula(column, formula[, …])

Compute a column based on applying a formula on the others.

ColumnFormula.fit(table_data)

Fit Constraint class to data.

ColumnFormula.transform(table_data)

Transform the table data.

ColumnFormula.fit_transform(table_data)

Fit this Constraint to the data and then transform it.

ColumnFormula.reverse_transform(table_data)

Reverse transform the table data.

ColumnFormula.is_valid(table_data)

Say whether the data fulfills the formula.

ColumnFormula.filter_valid(table_data)

Get only the rows that are valid.

ColumnFormula.from_dict(constraint_dict)

Build a Constraint object from a dict.

ColumnFormula.to_dict()

Return a dict representation of this Constraint.

Between

Between(column, low, high[, strict, …])

Ensure that the constraint_column is always between high and low.

Between.fit(table_data)

Fit Constraint class to data.

Between.transform(table_data)

Transform the table data.

Between.fit_transform(table_data)

Fit this Constraint to the data and then transform it.

Between.reverse_transform(table_data)

Reverse transform the table data.

Between.is_valid(table_data)

Say whether the constraint_column is between the low and high values.

Between.filter_valid(table_data)

Get only the rows that are valid.

Between.from_dict(constraint_dict)

Build a Constraint object from a dict.

Between.to_dict()

Return a dict representation of this Constraint.

Rounding

Rounding(columns, digits[, …])

Round a column based on the specified number of digits.

Rounding.fit(table_data)

Fit Constraint class to data.

Rounding.transform(table_data)

Perform necessary transformations needed by constraint.

Rounding.fit_transform(table_data)

Fit this Constraint to the data and then transform it.

Rounding.reverse_transform(table_data)

Reverse transform the table data.

Rounding.is_valid(table_data)

Determine if the data satisfies the rounding constraint.

Rounding.filter_valid(table_data)

Get only the rows that are valid.

Rounding.from_dict(constraint_dict)

Build a Constraint object from a dict.

Rounding.to_dict()

Return a dict representation of this Constraint.

OneHotEncoding

OneHotEncoding(columns[, handling_strategy])

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)

Reverse transform the table data.

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.