truthound-dashboard 1.4.4__py3-none-any.whl → 1.5.0__py3-none-any.whl

truthound_dashboard/schemas/triggers.py

@@ -509,3 +509,19 @@ class WebhookTriggerResponse(BaseModel):
     triggered_schedules: list[str] = Field(default_factory=list)
     message: str
     request_id: str
+
+
+class WebhookTestReceivedData(BaseModel):
+    """Data received in webhook test."""
+
+    source: str
+    event_type: str
+
+
+class WebhookTestResponse(BaseModel):
+    """Response schema for webhook test endpoint."""
+
+    message: str = Field(..., description="Test result message")
+    received: WebhookTestReceivedData = Field(
+        ..., description="Data that was received in the test request"
+    )

truthound_dashboard/schemas/unified_alerts.py

@@ -221,3 +221,10 @@ class BulkAlertActionResponse(BaseModel):
     success_count: int = Field(default=0, description="Number of successful updates")
     failed_count: int = Field(default=0, description="Number of failed updates")
     failed_ids: list[str] = Field(default_factory=list, description="IDs that failed")
+
+
+class AlertCountResponse(BaseModel):
+    """Response for alert count query."""
+
+    count: int = Field(..., description="Number of matching alerts")
+    status_filter: str = Field(..., description="Status filter applied")

truthound_dashboard/schemas/validation.py

@@ -102,13 +102,6 @@ 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,
@@ -116,12 +109,6 @@ class ValidationRunRequest(BaseSchema):
         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,

truthound_dashboard/schemas/validators/base.py

@@ -14,13 +14,18 @@ from pydantic import BaseModel, Field
 class ValidatorCategory(str, Enum):
     """Validator categories matching truthound's classification.
 
-    Categories are organized by validation purpose:
+    Categories are organized by validation purpose (21 total + infrastructure):
     - Core validators: schema, completeness, uniqueness, distribution
     - Format validators: string, datetime
     - Statistical validators: aggregate, anomaly, drift
     - Relational validators: cross_table, multi_column, query
-    - Domain validators: table, geospatial, privacy, business
-    - Advanced validators: time_series, referential, streaming
+    - Domain validators: table, geospatial, privacy
+    - Business validators: business_rule, profiling, localization
+    - ML validators: ml_feature
+    - Advanced validators: timeseries, referential
+
+    Infrastructure modules (not validator categories):
+    - sdk, security, i18n, timeout, streaming, memory, optimization
     """
 
     # Core validators (no extra dependencies)
@@ -47,12 +52,18 @@ class ValidatorCategory(str, Enum):
     TABLE = "table"
     GEOSPATIAL = "geospatial"
     PRIVACY = "privacy"
-    BUSINESS = "business"
+
+    # Business validators
+    BUSINESS_RULE = "business_rule"
+    PROFILING = "profiling"
+    LOCALIZATION = "localization"
+
+    # ML validators
+    ML_FEATURE = "ml_feature"
 
     # Advanced validators
-    TIME_SERIES = "time_series"
+    TIMESERIES = "timeseries"
     REFERENTIAL = "referential"
-    STREAMING = "streaming"
 
 
 class ParameterType(str, Enum):
@@ -171,20 +182,23 @@ def configs_to_truthound_format(
 ) -> tuple[list[str] | None, dict[str, dict[str, Any]]]:
     """Convert ValidatorConfig list to truthound-compatible format.
 
-    truthound supports two ways of specifying validators:
+    truthound 2.x supports two ways of specifying validators:
     1. Simple list of validator names: validators=["Null", "Duplicate"]
-    2. Dict-based configuration: validator_params={"Null": {"columns": ["a", "b"]}}
+    2. Dict-based configuration: validator_config={"Null": {"columns": ("a", "b")}}
 
     This function converts our ValidatorConfig format to both formats,
     allowing the caller to choose based on whether custom params exist.
 
+    Note: In truthound 2.x, columns parameters should be tuples, not lists.
+    This function automatically converts lists to tuples for compatibility.
+
     Args:
         configs: List of ValidatorConfig objects from API request.
 
     Returns:
-        Tuple of (validator_names, validator_params):
+        Tuple of (validator_names, validator_config):
         - validator_names: List of enabled validator names, or None if empty
-        - validator_params: Dict of {validator_name: {param: value}} for
+        - validator_config: Dict of {validator_name: {param: value}} for
           validators with non-default parameters
 
     Example:
@@ -193,14 +207,14 @@ def configs_to_truthound_format(
         ...     ValidatorConfig(name="Duplicate", enabled=True, params={}),
         ...     ValidatorConfig(name="Range", enabled=False, params={}),
         ... ]
-        >>> names, params = configs_to_truthound_format(configs)
+        >>> names, config = configs_to_truthound_format(configs)
         >>> names
         ['Null', 'Duplicate']
-        >>> params
-        {'Null': {'columns': ['a']}}
+        >>> config
+        {'Null': {'columns': ('a',)}}
     """
     enabled_names: list[str] = []
-    validator_params: dict[str, dict[str, Any]] = {}
+    validator_config: dict[str, dict[str, Any]] = {}
 
     for config in configs:
         if not config.enabled:
@@ -211,15 +225,21 @@ def configs_to_truthound_format(
         # Only include params that are non-empty
         if config.params:
             # Filter out None, empty strings, and empty lists
-            filtered_params = {
-                k: v
-                for k, v in config.params.items()
-                if v is not None and v != "" and v != []
-            }
+            filtered_params: dict[str, Any] = {}
+            for k, v in config.params.items():
+                if v is None or v == "" or v == []:
+                    continue
+                # Convert lists to tuples for truthound 2.x compatibility
+                # (columns parameter should be tuple, not list)
+                if isinstance(v, list):
+                    filtered_params[k] = tuple(v)
+                else:
+                    filtered_params[k] = v
+
             if filtered_params:
-                validator_params[config.name] = filtered_params
+                validator_config[config.name] = filtered_params
 
-    return enabled_names if enabled_names else None, validator_params
+    return enabled_names if enabled_names else None, validator_config
 
 
 def has_custom_params(configs: list[ValidatorConfig]) -> bool:

truthound_dashboard/schemas/validators/business_rule_validators.py

@@ -0,0 +1,244 @@
+"""Business rule validators.
+
+Validators for domain-specific business rules including checksums,
+financial identifiers (IBAN, VAT), and credit card validation.
+
+Import path in truthound: `from truthound.validators.business_rule import *`
+"""
+
+from .base import (
+    ParameterDefinition,
+    ParameterType,
+    ValidatorCategory,
+    ValidatorDefinition,
+)
+
+BUSINESS_RULE_VALIDATORS: list[ValidatorDefinition] = [
+    ValidatorDefinition(
+        name="Checksum",
+        display_name="Generic Checksum",
+        category=ValidatorCategory.BUSINESS_RULE,
+        description="Validates values using a generic checksum algorithm.",
+        parameters=[
+            ParameterDefinition(
+                name="column",
+                label="Column",
+                type=ParameterType.COLUMN,
+                required=True,
+                description="Column containing values to validate",
+            ),
+            ParameterDefinition(
+                name="algorithm",
+                label="Checksum Algorithm",
+                type=ParameterType.SELECT,
+                options=[
+                    {"value": "luhn", "label": "Luhn (Mod 10)"},
+                    {"value": "mod11", "label": "Modulo 11"},
+                    {"value": "verhoeff", "label": "Verhoeff"},
+                    {"value": "damm", "label": "Damm"},
+                ],
+                default="luhn",
+                description="Checksum algorithm to use",
+            ),
+        ],
+        tags=["business_rule", "checksum", "validation", "integrity"],
+        severity_default="high",
+    ),
+    ValidatorDefinition(
+        name="Luhn",
+        display_name="Luhn Algorithm (Mod 10)",
+        category=ValidatorCategory.BUSINESS_RULE,
+        description="Validates values using the Luhn algorithm (credit cards, IMEI, etc.).",
+        parameters=[
+            ParameterDefinition(
+                name="column",
+                label="Column",
+                type=ParameterType.COLUMN,
+                required=True,
+                description="Column containing numeric strings to validate",
+            ),
+        ],
+        tags=["business_rule", "luhn", "mod10", "credit_card"],
+        severity_default="high",
+    ),
+    ValidatorDefinition(
+        name="ISBN",
+        display_name="ISBN Validation",
+        category=ValidatorCategory.BUSINESS_RULE,
+        description="Validates ISBN-10 or ISBN-13 book identifiers.",
+        parameters=[
+            ParameterDefinition(
+                name="column",
+                label="Column",
+                type=ParameterType.COLUMN,
+                required=True,
+                description="Column containing ISBN values",
+            ),
+            ParameterDefinition(
+                name="format",
+                label="ISBN Format",
+                type=ParameterType.SELECT,
+                options=[
+                    {"value": "any", "label": "Any (ISBN-10 or ISBN-13)"},
+                    {"value": "isbn10", "label": "ISBN-10 Only"},
+                    {"value": "isbn13", "label": "ISBN-13 Only"},
+                ],
+                default="any",
+                description="Expected ISBN format",
+            ),
+        ],
+        tags=["business_rule", "isbn", "book", "identifier"],
+        severity_default="medium",
+    ),
+    ValidatorDefinition(
+        name="CreditCard",
+        display_name="Credit Card Number",
+        category=ValidatorCategory.BUSINESS_RULE,
+        description="Validates credit card numbers using Luhn algorithm and format checks.",
+        parameters=[
+            ParameterDefinition(
+                name="column",
+                label="Column",
+                type=ParameterType.COLUMN,
+                required=True,
+                description="Column containing credit card numbers",
+            ),
+            ParameterDefinition(
+                name="card_type",
+                label="Card Type",
+                type=ParameterType.MULTI_SELECT,
+                options=[
+                    {"value": "visa", "label": "Visa"},
+                    {"value": "mastercard", "label": "MasterCard"},
+                    {"value": "amex", "label": "American Express"},
+                    {"value": "discover", "label": "Discover"},
+                    {"value": "jcb", "label": "JCB"},
+                    {"value": "diners", "label": "Diners Club"},
+                ],
+                description="Accepted card types (empty = any)",
+            ),
+        ],
+        tags=["business_rule", "credit_card", "payment", "financial"],
+        severity_default="critical",
+    ),
+    ValidatorDefinition(
+        name="IBAN",
+        display_name="International Bank Account Number",
+        category=ValidatorCategory.BUSINESS_RULE,
+        description="Validates International Bank Account Numbers (IBAN).",
+        parameters=[
+            ParameterDefinition(
+                name="column",
+                label="Column",
+                type=ParameterType.COLUMN,
+                required=True,
+                description="Column containing IBAN values",
+            ),
+            ParameterDefinition(
+                name="country_codes",
+                label="Allowed Country Codes",
+                type=ParameterType.STRING_LIST,
+                description="Allowed country codes (e.g., DE, FR, GB). Empty = any.",
+                placeholder="DE, FR, GB",
+            ),
+        ],
+        tags=["business_rule", "iban", "bank", "financial"],
+        severity_default="high",
+    ),
+    ValidatorDefinition(
+        name="VAT",
+        display_name="VAT Number Validation",
+        category=ValidatorCategory.BUSINESS_RULE,
+        description="Validates Value Added Tax (VAT) identification numbers.",
+        parameters=[
+            ParameterDefinition(
+                name="column",
+                label="Column",
+                type=ParameterType.COLUMN,
+                required=True,
+                description="Column containing VAT numbers",
+            ),
+            ParameterDefinition(
+                name="country",
+                label="Country",
+                type=ParameterType.SELECT,
+                options=[
+                    {"value": "auto", "label": "Auto-detect"},
+                    {"value": "DE", "label": "Germany"},
+                    {"value": "FR", "label": "France"},
+                    {"value": "GB", "label": "United Kingdom"},
+                    {"value": "IT", "label": "Italy"},
+                    {"value": "ES", "label": "Spain"},
+                    {"value": "NL", "label": "Netherlands"},
+                    {"value": "BE", "label": "Belgium"},
+                    {"value": "AT", "label": "Austria"},
+                    {"value": "PL", "label": "Poland"},
+                ],
+                default="auto",
+                description="VAT number country format",
+            ),
+        ],
+        tags=["business_rule", "vat", "tax", "eu"],
+        severity_default="high",
+    ),
+    ValidatorDefinition(
+        name="SWIFT",
+        display_name="SWIFT/BIC Code Validation",
+        category=ValidatorCategory.BUSINESS_RULE,
+        description="Validates SWIFT/BIC bank identification codes.",
+        parameters=[
+            ParameterDefinition(
+                name="column",
+                label="Column",
+                type=ParameterType.COLUMN,
+                required=True,
+                description="Column containing SWIFT/BIC codes",
+            ),
+            ParameterDefinition(
+                name="format",
+                label="Code Format",
+                type=ParameterType.SELECT,
+                options=[
+                    {"value": "any", "label": "Any (8 or 11 characters)"},
+                    {"value": "bic8", "label": "BIC8 (8 characters)"},
+                    {"value": "bic11", "label": "BIC11 (11 characters)"},
+                ],
+                default="any",
+                description="Expected SWIFT/BIC format",
+            ),
+        ],
+        tags=["business_rule", "swift", "bic", "bank", "financial"],
+        severity_default="medium",
+    ),
+    ValidatorDefinition(
+        name="EAN",
+        display_name="EAN/UPC Barcode Validation",
+        category=ValidatorCategory.BUSINESS_RULE,
+        description="Validates EAN-8, EAN-13, UPC-A, or UPC-E barcodes.",
+        parameters=[
+            ParameterDefinition(
+                name="column",
+                label="Column",
+                type=ParameterType.COLUMN,
+                required=True,
+                description="Column containing barcode values",
+            ),
+            ParameterDefinition(
+                name="format",
+                label="Barcode Format",
+                type=ParameterType.SELECT,
+                options=[
+                    {"value": "any", "label": "Any (EAN/UPC)"},
+                    {"value": "ean8", "label": "EAN-8"},
+                    {"value": "ean13", "label": "EAN-13"},
+                    {"value": "upca", "label": "UPC-A"},
+                    {"value": "upce", "label": "UPC-E"},
+                ],
+                default="any",
+                description="Expected barcode format",
+            ),
+        ],
+        tags=["business_rule", "ean", "upc", "barcode", "product"],
+        severity_default="medium",
+    ),
+]