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

truthound_dashboard/schemas/validation.py

@@ -11,6 +11,7 @@ from typing import Any, Literal
 from pydantic import Field
 
 from .base import BaseSchema, IDMixin, ListResponseWrapper
+from .validators import ValidatorConfig
 
 # Validation status types
 ValidationStatus = Literal["pending", "running", "success", "failed", "error"]
@@ -42,13 +43,32 @@ class ValidationIssue(BaseSchema):
 
 
 class ValidationRunRequest(BaseSchema):
-    """Request to run validation on a source."""
+    """Request to run validation on a source.
 
+    This schema maps to truthound's th.check() parameters for maximum flexibility.
+    All optional parameters default to None/False to use truthound's defaults.
+
+    Supports two modes:
+    1. Simple mode: Use `validators` list with validator names (backward compatible)
+    2. Advanced mode: Use `validator_configs` for per-validator parameter configuration
+    """
+
+    # Core validation options - Simple mode (backward compatible)
     validators: list[str] | None = Field(
         default=None,
-        description="Specific validators to run. If None, all validators are used.",
-        examples=[["null", "duplicate", "schema"]],
+        description="Specific validators to run by name. If None, all validators are used.",
+        examples=[["Null", "Duplicate", "ColumnExists"]],
+    )
+
+    # Advanced mode - Per-validator configuration
+    validator_configs: list[ValidatorConfig] | None = Field(
+        default=None,
+        description=(
+            "Advanced: Configure individual validators with specific parameters. "
+            "Takes precedence over 'validators' list if provided."
+        ),
     )
+
     schema_path: str | None = Field(
         default=None,
         description="Path to schema YAML file for schema validation",
@@ -58,6 +78,43 @@ class ValidationRunRequest(BaseSchema):
         description="Auto-learn and cache schema for validation",
     )
 
+    # Column filtering
+    columns: list[str] | None = Field(
+        default=None,
+        description="Columns to validate. If None, all columns are validated.",
+        examples=[["user_id", "email", "created_at"]],
+    )
+
+    # Severity filtering
+    min_severity: Literal["low", "medium", "high", "critical"] | None = Field(
+        default=None,
+        description="Minimum severity level to report. Issues below this level are ignored.",
+        examples=["medium"],
+    )
+
+    # Execution behavior
+    strict: bool = Field(
+        default=False,
+        description="If True, raise exception on validation failures instead of returning results.",
+    )
+
+    # Performance options
+    parallel: bool = Field(
+        default=False,
+        description="If True, uses DAG-based parallel execution for validators.",
+    )
+    max_workers: int | None = Field(
+        default=None,
+        ge=1,
+        le=32,
+        description="Maximum number of worker threads for parallel execution. Only used when parallel=True.",
+        examples=[4, 8],
+    )
+    pushdown: bool | None = Field(
+        default=None,
+        description="Enable query pushdown optimization for SQL data sources. None uses auto-detection.",
+    )
+
 
 class ValidationSummary(BaseSchema):
     """Summary statistics for a validation run."""

truthound_dashboard/schemas/validators/__init__.py

@@ -0,0 +1,59 @@
+"""Validator registry module.
+
+This module provides a modular, extensible validator registry system.
+Each validator category is defined in a separate module for maintainability.
+
+Usage:
+    from truthound_dashboard.schemas.validators import (
+        VALIDATOR_REGISTRY,
+        get_validator_by_name,
+        get_validators_by_category,
+        search_validators,
+        ValidatorDefinition,
+        ValidatorConfig,
+        ValidatorCategory,
+    )
+"""
+
+from __future__ import annotations
+
+from .base import (
+    ParameterDefinition,
+    ParameterType,
+    ValidatorCategory,
+    ValidatorConfig,
+    ValidatorConfigList,
+    ValidatorDefinition,
+    configs_to_truthound_format,
+    has_custom_params,
+    merge_severity_overrides,
+)
+from .registry import (
+    VALIDATOR_REGISTRY,
+    get_validator_by_name,
+    get_validators_by_category,
+    search_validators,
+    get_category_info,
+    CATEGORY_INFO,
+)
+
+__all__ = [
+    # Base types
+    "ParameterDefinition",
+    "ParameterType",
+    "ValidatorCategory",
+    "ValidatorConfig",
+    "ValidatorConfigList",
+    "ValidatorDefinition",
+    # Utility functions
+    "configs_to_truthound_format",
+    "has_custom_params",
+    "merge_severity_overrides",
+    # Registry
+    "VALIDATOR_REGISTRY",
+    "get_validator_by_name",
+    "get_validators_by_category",
+    "search_validators",
+    "get_category_info",
+    "CATEGORY_INFO",
+]

truthound_dashboard/schemas/validators/aggregate_validators.py

@@ -0,0 +1,238 @@
+"""Aggregate validators.
+
+Validators for column-level statistical verification.
+"""
+
+from .base import (
+    ParameterDefinition,
+    ParameterType,
+    ValidatorCategory,
+    ValidatorDefinition,
+)
+
+AGGREGATE_VALIDATORS: list[ValidatorDefinition] = [
+    ValidatorDefinition(
+        name="MeanBetween",
+        display_name="Mean Between",
+        category=ValidatorCategory.AGGREGATE,
+        description="Validates that the column mean falls within a specified range.",
+        parameters=[
+            ParameterDefinition(
+                name="column",
+                label="Column",
+                type=ParameterType.COLUMN,
+                required=True,
+            ),
+            ParameterDefinition(
+                name="min_value",
+                label="Minimum Mean",
+                type=ParameterType.FLOAT,
+                description="Minimum acceptable mean value",
+            ),
+            ParameterDefinition(
+                name="max_value",
+                label="Maximum Mean",
+                type=ParameterType.FLOAT,
+                description="Maximum acceptable mean value",
+            ),
+        ],
+        tags=["aggregate", "mean", "average", "statistical"],
+        severity_default="medium",
+    ),
+    ValidatorDefinition(
+        name="MedianBetween",
+        display_name="Median Between",
+        category=ValidatorCategory.AGGREGATE,
+        description="Validates that the column median falls within a specified range.",
+        parameters=[
+            ParameterDefinition(
+                name="column",
+                label="Column",
+                type=ParameterType.COLUMN,
+                required=True,
+            ),
+            ParameterDefinition(
+                name="min_value",
+                label="Minimum Median",
+                type=ParameterType.FLOAT,
+                description="Minimum acceptable median value",
+            ),
+            ParameterDefinition(
+                name="max_value",
+                label="Maximum Median",
+                type=ParameterType.FLOAT,
+                description="Maximum acceptable median value",
+            ),
+        ],
+        tags=["aggregate", "median", "statistical"],
+        severity_default="medium",
+    ),
+    ValidatorDefinition(
+        name="StdBetween",
+        display_name="Standard Deviation Between",
+        category=ValidatorCategory.AGGREGATE,
+        description="Validates that the column standard deviation falls within a specified range.",
+        parameters=[
+            ParameterDefinition(
+                name="column",
+                label="Column",
+                type=ParameterType.COLUMN,
+                required=True,
+            ),
+            ParameterDefinition(
+                name="min_value",
+                label="Minimum Std Dev",
+                type=ParameterType.FLOAT,
+                description="Minimum acceptable standard deviation",
+                min_value=0,
+            ),
+            ParameterDefinition(
+                name="max_value",
+                label="Maximum Std Dev",
+                type=ParameterType.FLOAT,
+                description="Maximum acceptable standard deviation",
+                min_value=0,
+            ),
+        ],
+        tags=["aggregate", "std", "standard_deviation", "statistical"],
+        severity_default="medium",
+    ),
+    ValidatorDefinition(
+        name="VarianceBetween",
+        display_name="Variance Between",
+        category=ValidatorCategory.AGGREGATE,
+        description="Validates that the column variance falls within a specified range.",
+        parameters=[
+            ParameterDefinition(
+                name="column",
+                label="Column",
+                type=ParameterType.COLUMN,
+                required=True,
+            ),
+            ParameterDefinition(
+                name="min_value",
+                label="Minimum Variance",
+                type=ParameterType.FLOAT,
+                description="Minimum acceptable variance",
+                min_value=0,
+            ),
+            ParameterDefinition(
+                name="max_value",
+                label="Maximum Variance",
+                type=ParameterType.FLOAT,
+                description="Maximum acceptable variance",
+                min_value=0,
+            ),
+        ],
+        tags=["aggregate", "variance", "statistical"],
+        severity_default="medium",
+    ),
+    ValidatorDefinition(
+        name="SumBetween",
+        display_name="Sum Between",
+        category=ValidatorCategory.AGGREGATE,
+        description="Validates that the column sum falls within a specified range.",
+        parameters=[
+            ParameterDefinition(
+                name="column",
+                label="Column",
+                type=ParameterType.COLUMN,
+                required=True,
+            ),
+            ParameterDefinition(
+                name="min_value",
+                label="Minimum Sum",
+                type=ParameterType.FLOAT,
+                description="Minimum acceptable sum value",
+            ),
+            ParameterDefinition(
+                name="max_value",
+                label="Maximum Sum",
+                type=ParameterType.FLOAT,
+                description="Maximum acceptable sum value",
+            ),
+        ],
+        tags=["aggregate", "sum", "total", "statistical"],
+        severity_default="medium",
+    ),
+    ValidatorDefinition(
+        name="MinBetween",
+        display_name="Min Value Between",
+        category=ValidatorCategory.AGGREGATE,
+        description="Validates that the column minimum value falls within a specified range.",
+        parameters=[
+            ParameterDefinition(
+                name="column",
+                label="Column",
+                type=ParameterType.COLUMN,
+                required=True,
+            ),
+            ParameterDefinition(
+                name="min_value",
+                label="Minimum of Min",
+                type=ParameterType.FLOAT,
+                description="Lower bound for the column minimum",
+            ),
+            ParameterDefinition(
+                name="max_value",
+                label="Maximum of Min",
+                type=ParameterType.FLOAT,
+                description="Upper bound for the column minimum",
+            ),
+        ],
+        tags=["aggregate", "min", "minimum", "bounds"],
+        severity_default="medium",
+    ),
+    ValidatorDefinition(
+        name="MaxBetween",
+        display_name="Max Value Between",
+        category=ValidatorCategory.AGGREGATE,
+        description="Validates that the column maximum value falls within a specified range.",
+        parameters=[
+            ParameterDefinition(
+                name="column",
+                label="Column",
+                type=ParameterType.COLUMN,
+                required=True,
+            ),
+            ParameterDefinition(
+                name="min_value",
+                label="Minimum of Max",
+                type=ParameterType.FLOAT,
+                description="Lower bound for the column maximum",
+            ),
+            ParameterDefinition(
+                name="max_value",
+                label="Maximum of Max",
+                type=ParameterType.FLOAT,
+                description="Upper bound for the column maximum",
+            ),
+        ],
+        tags=["aggregate", "max", "maximum", "bounds"],
+        severity_default="medium",
+    ),
+    ValidatorDefinition(
+        name="CountBetween",
+        display_name="Count Between",
+        category=ValidatorCategory.AGGREGATE,
+        description="Validates that the row count falls within a specified range.",
+        parameters=[
+            ParameterDefinition(
+                name="min_count",
+                label="Minimum Count",
+                type=ParameterType.INTEGER,
+                description="Minimum acceptable row count",
+                min_value=0,
+            ),
+            ParameterDefinition(
+                name="max_count",
+                label="Maximum Count",
+                type=ParameterType.INTEGER,
+                description="Maximum acceptable row count",
+                min_value=0,
+            ),
+        ],
+        tags=["aggregate", "count", "rows"],
+        severity_default="medium",
+    ),
+]