truthound-dashboard 1.2.1__py3-none-any.whl → 1.3.1__py3-none-any.whl

truthound_dashboard/schemas/validators/multi_column_validators.py

@@ -0,0 +1,706 @@
+"""Multi-column validators.
+
+Validators for cross-column relationships, calculations, and constraints.
+"""
+
+from .base import (
+    ParameterDefinition,
+    ParameterType,
+    ValidatorCategory,
+    ValidatorDefinition,
+)
+
+MULTI_COLUMN_VALIDATORS: list[ValidatorDefinition] = [
+    ValidatorDefinition(
+        name="ColumnComparison",
+        display_name="Column Comparison",
+        category=ValidatorCategory.MULTI_COLUMN,
+        description="Compares values between two columns using an operator.",
+        parameters=[
+            ParameterDefinition(
+                name="column_a",
+                label="First Column",
+                type=ParameterType.COLUMN,
+                required=True,
+            ),
+            ParameterDefinition(
+                name="column_b",
+                label="Second Column",
+                type=ParameterType.COLUMN,
+                required=True,
+            ),
+            ParameterDefinition(
+                name="operator",
+                label="Operator",
+                type=ParameterType.SELECT,
+                required=True,
+                options=[
+                    {"value": "eq", "label": "Equal (=)"},
+                    {"value": "ne", "label": "Not Equal (!=)"},
+                    {"value": "gt", "label": "Greater Than (>)"},
+                    {"value": "gte", "label": "Greater Than or Equal (>=)"},
+                    {"value": "lt", "label": "Less Than (<)"},
+                    {"value": "lte", "label": "Less Than or Equal (<=)"},
+                ],
+            ),
+            ParameterDefinition(
+                name="mostly",
+                label="Mostly (Threshold)",
+                type=ParameterType.FLOAT,
+                description="Acceptable pass ratio (0.0-1.0)",
+                min_value=0,
+                max_value=1,
+            ),
+        ],
+        tags=["multi_column", "comparison", "relationship"],
+        severity_default="medium",
+    ),
+    ValidatorDefinition(
+        name="ColumnArithmetic",
+        display_name="Column Arithmetic",
+        category=ValidatorCategory.MULTI_COLUMN,
+        description="Validates arithmetic relationships between columns (A op B = C).",
+        parameters=[
+            ParameterDefinition(
+                name="column_a",
+                label="First Operand Column",
+                type=ParameterType.COLUMN,
+                required=True,
+            ),
+            ParameterDefinition(
+                name="column_b",
+                label="Second Operand Column",
+                type=ParameterType.COLUMN,
+                required=True,
+            ),
+            ParameterDefinition(
+                name="result_column",
+                label="Result Column",
+                type=ParameterType.COLUMN,
+                description="Column that should contain the result",
+                required=True,
+            ),
+            ParameterDefinition(
+                name="operation",
+                label="Operation",
+                type=ParameterType.SELECT,
+                required=True,
+                options=[
+                    {"value": "add", "label": "Addition (A + B)"},
+                    {"value": "subtract", "label": "Subtraction (A - B)"},
+                    {"value": "multiply", "label": "Multiplication (A * B)"},
+                    {"value": "divide", "label": "Division (A / B)"},
+                    {"value": "modulo", "label": "Modulo (A % B)"},
+                ],
+            ),
+            ParameterDefinition(
+                name="tolerance",
+                label="Tolerance",
+                type=ParameterType.FLOAT,
+                description="Acceptable tolerance for floating point comparison",
+                default=0.0001,
+                min_value=0,
+            ),
+        ],
+        tags=["multi_column", "arithmetic", "calculation"],
+        severity_default="medium",
+    ),
+    ValidatorDefinition(
+        name="ColumnSum",
+        display_name="Column Sum",
+        category=ValidatorCategory.MULTI_COLUMN,
+        description="Validates that sum of columns equals a target column.",
+        parameters=[
+            ParameterDefinition(
+                name="columns",
+                label="Source Columns",
+                type=ParameterType.COLUMN_LIST,
+                description="Columns to sum together",
+                required=True,
+            ),
+            ParameterDefinition(
+                name="target_column",
+                label="Target Column",
+                type=ParameterType.COLUMN,
+                description="Column that should equal the sum",
+                required=True,
+            ),
+            ParameterDefinition(
+                name="tolerance",
+                label="Tolerance",
+                type=ParameterType.FLOAT,
+                default=0.0001,
+                min_value=0,
+            ),
+        ],
+        tags=["multi_column", "sum", "calculation"],
+        severity_default="medium",
+    ),
+    ValidatorDefinition(
+        name="ColumnRatio",
+        display_name="Column Ratio",
+        category=ValidatorCategory.MULTI_COLUMN,
+        description="Validates that ratio of two columns meets expectations.",
+        parameters=[
+            ParameterDefinition(
+                name="numerator_column",
+                label="Numerator Column",
+                type=ParameterType.COLUMN,
+                required=True,
+            ),
+            ParameterDefinition(
+                name="denominator_column",
+                label="Denominator Column",
+                type=ParameterType.COLUMN,
+                required=True,
+            ),
+            ParameterDefinition(
+                name="expected_ratio",
+                label="Expected Ratio",
+                type=ParameterType.FLOAT,
+                description="Expected ratio value",
+            ),
+            ParameterDefinition(
+                name="min_ratio",
+                label="Minimum Ratio",
+                type=ParameterType.FLOAT,
+                description="Minimum acceptable ratio",
+            ),
+            ParameterDefinition(
+                name="max_ratio",
+                label="Maximum Ratio",
+                type=ParameterType.FLOAT,
+                description="Maximum acceptable ratio",
+            ),
+            ParameterDefinition(
+                name="tolerance",
+                label="Tolerance",
+                type=ParameterType.FLOAT,
+                default=0.01,
+                min_value=0,
+            ),
+        ],
+        tags=["multi_column", "ratio", "calculation"],
+        severity_default="medium",
+    ),
+    ValidatorDefinition(
+        name="ColumnCorrelation",
+        display_name="Column Correlation",
+        category=ValidatorCategory.MULTI_COLUMN,
+        description="Validates Pearson correlation between two numeric columns.",
+        parameters=[
+            ParameterDefinition(
+                name="column_a",
+                label="First Column",
+                type=ParameterType.COLUMN,
+                required=True,
+            ),
+            ParameterDefinition(
+                name="column_b",
+                label="Second Column",
+                type=ParameterType.COLUMN,
+                required=True,
+            ),
+            ParameterDefinition(
+                name="min_correlation",
+                label="Minimum Correlation",
+                type=ParameterType.FLOAT,
+                description="Minimum expected correlation coefficient",
+                min_value=-1,
+                max_value=1,
+            ),
+            ParameterDefinition(
+                name="max_correlation",
+                label="Maximum Correlation",
+                type=ParameterType.FLOAT,
+                description="Maximum expected correlation coefficient",
+                min_value=-1,
+                max_value=1,
+            ),
+        ],
+        tags=["multi_column", "correlation", "statistics"],
+        severity_default="medium",
+    ),
+    ValidatorDefinition(
+        name="ColumnDependency",
+        display_name="Column Dependency",
+        category=ValidatorCategory.MULTI_COLUMN,
+        description="Validates functional dependency: if A then B (determinant -> dependent).",
+        parameters=[
+            ParameterDefinition(
+                name="determinant_column",
+                label="Determinant Column",
+                type=ParameterType.COLUMN,
+                description="Column that determines the value of another",
+                required=True,
+            ),
+            ParameterDefinition(
+                name="dependent_column",
+                label="Dependent Column",
+                type=ParameterType.COLUMN,
+                description="Column whose value is determined by the determinant",
+                required=True,
+            ),
+            ParameterDefinition(
+                name="allow_null",
+                label="Allow Null",
+                type=ParameterType.BOOLEAN,
+                description="Allow null values in dependent column",
+                default=True,
+            ),
+        ],
+        tags=["multi_column", "dependency", "functional"],
+        severity_default="high",
+    ),
+    ValidatorDefinition(
+        name="Conditional",
+        display_name="Conditional",
+        category=ValidatorCategory.MULTI_COLUMN,
+        description="Validates conditional logic: if condition then expectation.",
+        parameters=[
+            ParameterDefinition(
+                name="when_column",
+                label="Condition Column",
+                type=ParameterType.COLUMN,
+                description="Column to check condition against",
+                required=True,
+            ),
+            ParameterDefinition(
+                name="when_value",
+                label="Condition Value",
+                type=ParameterType.STRING,
+                description="Value that triggers the expectation",
+                required=True,
+            ),
+            ParameterDefinition(
+                name="then_column",
+                label="Then Column",
+                type=ParameterType.COLUMN,
+                description="Column to validate when condition is met",
+                required=True,
+            ),
+            ParameterDefinition(
+                name="then_operator",
+                label="Then Operator",
+                type=ParameterType.SELECT,
+                required=True,
+                options=[
+                    {"value": "not_null", "label": "Not Null"},
+                    {"value": "null", "label": "Null"},
+                    {"value": "eq", "label": "Equals"},
+                    {"value": "ne", "label": "Not Equals"},
+                    {"value": "gt", "label": "Greater Than"},
+                    {"value": "lt", "label": "Less Than"},
+                    {"value": "in_set", "label": "In Set"},
+                ],
+            ),
+            ParameterDefinition(
+                name="then_value",
+                label="Then Value",
+                type=ParameterType.STRING,
+                description="Expected value (for eq/ne/gt/lt operators)",
+                depends_on="then_operator",
+                depends_value="eq",
+            ),
+        ],
+        tags=["multi_column", "conditional", "business_rule"],
+        severity_default="high",
+    ),
+    ValidatorDefinition(
+        name="ColumnChainComparison",
+        display_name="Column Chain Comparison",
+        category=ValidatorCategory.MULTI_COLUMN,
+        description="Validates ordered relationships across multiple columns (A < B < C).",
+        parameters=[
+            ParameterDefinition(
+                name="columns",
+                label="Columns (in order)",
+                type=ParameterType.COLUMN_LIST,
+                description="Columns to compare in sequence",
+                required=True,
+            ),
+            ParameterDefinition(
+                name="operator",
+                label="Operator",
+                type=ParameterType.SELECT,
+                required=True,
+                options=[
+                    {"value": "lt", "label": "Less Than (<)"},
+                    {"value": "lte", "label": "Less Than or Equal (<=)"},
+                    {"value": "gt", "label": "Greater Than (>)"},
+                    {"value": "gte", "label": "Greater Than or Equal (>=)"},
+                ],
+            ),
+            ParameterDefinition(
+                name="strict",
+                label="Strict",
+                type=ParameterType.BOOLEAN,
+                description="If true, use strict comparison (< instead of <=)",
+                default=True,
+            ),
+        ],
+        tags=["multi_column", "chain", "ordering"],
+        severity_default="medium",
+    ),
+    ValidatorDefinition(
+        name="ColumnConsistency",
+        display_name="Column Consistency",
+        category=ValidatorCategory.MULTI_COLUMN,
+        description="Validates that column values are consistent within groupings.",
+        parameters=[
+            ParameterDefinition(
+                name="columns",
+                label="Columns to Check",
+                type=ParameterType.COLUMN_LIST,
+                description="Columns that should be consistent",
+                required=True,
+            ),
+            ParameterDefinition(
+                name="group_by",
+                label="Group By Columns",
+                type=ParameterType.COLUMN_LIST,
+                description="Columns to group by for consistency check",
+                required=True,
+            ),
+        ],
+        tags=["multi_column", "consistency", "grouping"],
+        severity_default="medium",
+    ),
+    ValidatorDefinition(
+        name="MutualExclusivity",
+        display_name="Mutual Exclusivity",
+        category=ValidatorCategory.MULTI_COLUMN,
+        description="Ensures at most one column in a group has a non-null value.",
+        parameters=[
+            ParameterDefinition(
+                name="columns",
+                label="Columns",
+                type=ParameterType.COLUMN_LIST,
+                description="Columns that are mutually exclusive",
+                required=True,
+            ),
+            ParameterDefinition(
+                name="allow_all_null",
+                label="Allow All Null",
+                type=ParameterType.BOOLEAN,
+                description="Allow all columns to be null",
+                default=True,
+            ),
+        ],
+        tags=["multi_column", "mutex", "exclusive"],
+        severity_default="high",
+    ),
+    ValidatorDefinition(
+        name="ColumnCoexistence",
+        display_name="Column Coexistence",
+        category=ValidatorCategory.MULTI_COLUMN,
+        description="Ensures columns are either all null or all non-null together.",
+        parameters=[
+            ParameterDefinition(
+                name="columns",
+                label="Columns",
+                type=ParameterType.COLUMN_LIST,
+                description="Columns that must coexist",
+                required=True,
+            ),
+        ],
+        tags=["multi_column", "coexistence", "group"],
+        severity_default="medium",
+    ),
+    ValidatorDefinition(
+        name="ColumnImplication",
+        display_name="Column Implication",
+        category=ValidatorCategory.MULTI_COLUMN,
+        description="Validates implication logic: if A then B (antecedent -> consequent).",
+        parameters=[
+            ParameterDefinition(
+                name="antecedent_column",
+                label="If Column (Antecedent)",
+                type=ParameterType.COLUMN,
+                required=True,
+            ),
+            ParameterDefinition(
+                name="antecedent_condition",
+                label="If Condition",
+                type=ParameterType.EXPRESSION,
+                description="Condition expression for antecedent",
+                required=True,
+                placeholder="!= null",
+            ),
+            ParameterDefinition(
+                name="consequent_column",
+                label="Then Column (Consequent)",
+                type=ParameterType.COLUMN,
+                required=True,
+            ),
+            ParameterDefinition(
+                name="consequent_condition",
+                label="Then Condition",
+                type=ParameterType.EXPRESSION,
+                description="Condition expression for consequent",
+                required=True,
+                placeholder="!= null",
+            ),
+        ],
+        tags=["multi_column", "implication", "logic"],
+        severity_default="medium",
+    ),
+    ValidatorDefinition(
+        name="ColumnMax",
+        display_name="Column Maximum",
+        category=ValidatorCategory.MULTI_COLUMN,
+        description="Validates that a column contains the maximum value among a set.",
+        parameters=[
+            ParameterDefinition(
+                name="max_column",
+                label="Maximum Column",
+                type=ParameterType.COLUMN,
+                description="Column that should contain the maximum",
+                required=True,
+            ),
+            ParameterDefinition(
+                name="source_columns",
+                label="Source Columns",
+                type=ParameterType.COLUMN_LIST,
+                description="Columns to compare for maximum",
+                required=True,
+            ),
+        ],
+        tags=["multi_column", "max", "aggregate"],
+        severity_default="medium",
+    ),
+    ValidatorDefinition(
+        name="ColumnMin",
+        display_name="Column Minimum",
+        category=ValidatorCategory.MULTI_COLUMN,
+        description="Validates that a column contains the minimum value among a set.",
+        parameters=[
+            ParameterDefinition(
+                name="min_column",
+                label="Minimum Column",
+                type=ParameterType.COLUMN,
+                description="Column that should contain the minimum",
+                required=True,
+            ),
+            ParameterDefinition(
+                name="source_columns",
+                label="Source Columns",
+                type=ParameterType.COLUMN_LIST,
+                description="Columns to compare for minimum",
+                required=True,
+            ),
+        ],
+        tags=["multi_column", "min", "aggregate"],
+        severity_default="medium",
+    ),
+    ValidatorDefinition(
+        name="ColumnMean",
+        display_name="Column Mean",
+        category=ValidatorCategory.MULTI_COLUMN,
+        description="Validates that mean of selected columns falls within a range.",
+        parameters=[
+            ParameterDefinition(
+                name="columns",
+                label="Columns",
+                type=ParameterType.COLUMN_LIST,
+                description="Columns to calculate mean across",
+                required=True,
+            ),
+            ParameterDefinition(
+                name="min_value",
+                label="Minimum Mean",
+                type=ParameterType.FLOAT,
+            ),
+            ParameterDefinition(
+                name="max_value",
+                label="Maximum Mean",
+                type=ParameterType.FLOAT,
+            ),
+        ],
+        tags=["multi_column", "mean", "aggregate"],
+        severity_default="medium",
+    ),
+    ValidatorDefinition(
+        name="ColumnVariance",
+        display_name="Column Variance",
+        category=ValidatorCategory.MULTI_COLUMN,
+        description="Validates variance across multiple columns.",
+        parameters=[
+            ParameterDefinition(
+                name="columns",
+                label="Columns",
+                type=ParameterType.COLUMN_LIST,
+                description="Columns to calculate variance across",
+                required=True,
+            ),
+            ParameterDefinition(
+                name="min_variance",
+                label="Minimum Variance",
+                type=ParameterType.FLOAT,
+                min_value=0,
+            ),
+            ParameterDefinition(
+                name="max_variance",
+                label="Maximum Variance",
+                type=ParameterType.FLOAT,
+                min_value=0,
+            ),
+        ],
+        tags=["multi_column", "variance", "statistics"],
+        severity_default="medium",
+    ),
+    ValidatorDefinition(
+        name="ColumnCovariance",
+        display_name="Column Covariance",
+        category=ValidatorCategory.MULTI_COLUMN,
+        description="Validates covariance between two columns.",
+        parameters=[
+            ParameterDefinition(
+                name="column_a",
+                label="First Column",
+                type=ParameterType.COLUMN,
+                required=True,
+            ),
+            ParameterDefinition(
+                name="column_b",
+                label="Second Column",
+                type=ParameterType.COLUMN,
+                required=True,
+            ),
+            ParameterDefinition(
+                name="min_covariance",
+                label="Minimum Covariance",
+                type=ParameterType.FLOAT,
+            ),
+            ParameterDefinition(
+                name="max_covariance",
+                label="Maximum Covariance",
+                type=ParameterType.FLOAT,
+            ),
+        ],
+        tags=["multi_column", "covariance", "statistics"],
+        severity_default="medium",
+    ),
+    ValidatorDefinition(
+        name="ColumnProduct",
+        display_name="Column Product",
+        category=ValidatorCategory.MULTI_COLUMN,
+        description="Validates that product of columns equals a target column.",
+        parameters=[
+            ParameterDefinition(
+                name="columns",
+                label="Source Columns",
+                type=ParameterType.COLUMN_LIST,
+                description="Columns to multiply together",
+                required=True,
+            ),
+            ParameterDefinition(
+                name="target_column",
+                label="Target Column",
+                type=ParameterType.COLUMN,
+                description="Column that should equal the product",
+                required=True,
+            ),
+            ParameterDefinition(
+                name="tolerance",
+                label="Tolerance",
+                type=ParameterType.FLOAT,
+                default=0.0001,
+                min_value=0,
+            ),
+        ],
+        tags=["multi_column", "product", "calculation"],
+        severity_default="medium",
+    ),
+    ValidatorDefinition(
+        name="ColumnDifference",
+        display_name="Column Difference",
+        category=ValidatorCategory.MULTI_COLUMN,
+        description="Validates the difference between two columns.",
+        parameters=[
+            ParameterDefinition(
+                name="column_a",
+                label="First Column",
+                type=ParameterType.COLUMN,
+                required=True,
+            ),
+            ParameterDefinition(
+                name="column_b",
+                label="Second Column",
+                type=ParameterType.COLUMN,
+                required=True,
+            ),
+            ParameterDefinition(
+                name="expected_difference",
+                label="Expected Difference",
+                type=ParameterType.FLOAT,
+                description="Expected value of (A - B)",
+            ),
+            ParameterDefinition(
+                name="min_difference",
+                label="Minimum Difference",
+                type=ParameterType.FLOAT,
+            ),
+            ParameterDefinition(
+                name="max_difference",
+                label="Maximum Difference",
+                type=ParameterType.FLOAT,
+            ),
+            ParameterDefinition(
+                name="tolerance",
+                label="Tolerance",
+                type=ParameterType.FLOAT,
+                default=0.0001,
+                min_value=0,
+            ),
+        ],
+        tags=["multi_column", "difference", "calculation"],
+        severity_default="medium",
+    ),
+    ValidatorDefinition(
+        name="ColumnPercentage",
+        display_name="Column Percentage",
+        category=ValidatorCategory.MULTI_COLUMN,
+        description="Validates percentage relationship between columns.",
+        parameters=[
+            ParameterDefinition(
+                name="numerator_column",
+                label="Numerator Column",
+                type=ParameterType.COLUMN,
+                required=True,
+            ),
+            ParameterDefinition(
+                name="denominator_column",
+                label="Denominator Column",
+                type=ParameterType.COLUMN,
+                required=True,
+            ),
+            ParameterDefinition(
+                name="expected_percentage",
+                label="Expected Percentage",
+                type=ParameterType.FLOAT,
+                description="Expected percentage (0-100)",
+            ),
+            ParameterDefinition(
+                name="min_percentage",
+                label="Minimum Percentage",
+                type=ParameterType.FLOAT,
+                min_value=0,
+            ),
+            ParameterDefinition(
+                name="max_percentage",
+                label="Maximum Percentage",
+                type=ParameterType.FLOAT,
+            ),
+            ParameterDefinition(
+                name="tolerance",
+                label="Tolerance",
+                type=ParameterType.FLOAT,
+                default=0.1,
+                min_value=0,
+            ),
+        ],
+        tags=["multi_column", "percentage", "calculation"],
+        severity_default="medium",
+    ),
+]