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

truthound_dashboard/schemas/validators/uniqueness_validators.py

@@ -0,0 +1,355 @@
+"""Uniqueness validators.
+
+Validators for detecting duplicates, validating keys, and ensuring distinctness.
+"""
+
+from .base import (
+    ParameterDefinition,
+    ParameterType,
+    ValidatorCategory,
+    ValidatorDefinition,
+)
+
+UNIQUENESS_VALIDATORS: list[ValidatorDefinition] = [
+    ValidatorDefinition(
+        name="Unique",
+        display_name="Unique",
+        category=ValidatorCategory.UNIQUENESS,
+        description="Ensures all values in a column are unique.",
+        parameters=[
+            ParameterDefinition(
+                name="column",
+                label="Column",
+                type=ParameterType.COLUMN,
+                required=True,
+            ),
+            ParameterDefinition(
+                name="mostly",
+                label="Mostly (Threshold)",
+                type=ParameterType.FLOAT,
+                description="Minimum unique ratio (0.0-1.0)",
+                min_value=0,
+                max_value=1,
+            ),
+        ],
+        tags=["uniqueness", "duplicate", "distinct"],
+        severity_default="high",
+    ),
+    ValidatorDefinition(
+        name="UniqueRatio",
+        display_name="Unique Ratio",
+        category=ValidatorCategory.UNIQUENESS,
+        description="Validates that the unique value ratio falls within a range.",
+        parameters=[
+            ParameterDefinition(
+                name="column",
+                label="Column",
+                type=ParameterType.COLUMN,
+                required=True,
+            ),
+            ParameterDefinition(
+                name="min_ratio",
+                label="Minimum Ratio",
+                type=ParameterType.FLOAT,
+                min_value=0,
+                max_value=1,
+            ),
+            ParameterDefinition(
+                name="max_ratio",
+                label="Maximum Ratio",
+                type=ParameterType.FLOAT,
+                min_value=0,
+                max_value=1,
+            ),
+        ],
+        tags=["uniqueness", "ratio"],
+        severity_default="medium",
+    ),
+    ValidatorDefinition(
+        name="DistinctCount",
+        display_name="Distinct Count",
+        category=ValidatorCategory.UNIQUENESS,
+        description="Validates the number of distinct values in a column.",
+        parameters=[
+            ParameterDefinition(
+                name="column",
+                label="Column",
+                type=ParameterType.COLUMN,
+                required=True,
+            ),
+            ParameterDefinition(
+                name="min_count",
+                label="Minimum Count",
+                type=ParameterType.INTEGER,
+                min_value=0,
+            ),
+            ParameterDefinition(
+                name="max_count",
+                label="Maximum Count",
+                type=ParameterType.INTEGER,
+                min_value=0,
+            ),
+        ],
+        tags=["uniqueness", "distinct", "count"],
+        severity_default="medium",
+    ),
+    ValidatorDefinition(
+        name="Duplicate",
+        display_name="Duplicate Detection",
+        category=ValidatorCategory.UNIQUENESS,
+        description="Detects duplicate values within specified columns.",
+        parameters=[
+            ParameterDefinition(
+                name="columns",
+                label="Columns",
+                type=ParameterType.COLUMN_LIST,
+                description="Columns to check for duplicates (leave empty for all)",
+            ),
+        ],
+        tags=["uniqueness", "duplicate"],
+        severity_default="high",
+    ),
+    ValidatorDefinition(
+        name="DuplicateWithinGroup",
+        display_name="Duplicate Within Group",
+        category=ValidatorCategory.UNIQUENESS,
+        description="Detects duplicates within specified groups.",
+        parameters=[
+            ParameterDefinition(
+                name="column",
+                label="Column to Check",
+                type=ParameterType.COLUMN,
+                description="Column to check for duplicates",
+                required=True,
+            ),
+            ParameterDefinition(
+                name="group_by",
+                label="Group By Columns",
+                type=ParameterType.COLUMN_LIST,
+                description="Columns to group by",
+                required=True,
+            ),
+        ],
+        tags=["uniqueness", "duplicate", "group"],
+        severity_default="high",
+    ),
+    ValidatorDefinition(
+        name="PrimaryKey",
+        display_name="Primary Key",
+        category=ValidatorCategory.UNIQUENESS,
+        description="Validates primary key constraints (unique and non-null).",
+        parameters=[
+            ParameterDefinition(
+                name="column",
+                label="Primary Key Column",
+                type=ParameterType.COLUMN,
+                required=True,
+            ),
+        ],
+        tags=["uniqueness", "primary_key", "constraint"],
+        severity_default="critical",
+    ),
+    ValidatorDefinition(
+        name="CompoundKey",
+        display_name="Compound Key",
+        category=ValidatorCategory.UNIQUENESS,
+        description="Validates composite primary key constraints.",
+        parameters=[
+            ParameterDefinition(
+                name="columns",
+                label="Key Columns",
+                type=ParameterType.COLUMN_LIST,
+                description="Columns forming the compound key",
+                required=True,
+            ),
+        ],
+        tags=["uniqueness", "compound_key", "composite"],
+        severity_default="critical",
+    ),
+    ValidatorDefinition(
+        name="DistinctValuesInSet",
+        display_name="Distinct Values In Set",
+        category=ValidatorCategory.UNIQUENESS,
+        description="Ensures all distinct values belong to a specified set.",
+        parameters=[
+            ParameterDefinition(
+                name="column",
+                label="Column",
+                type=ParameterType.COLUMN,
+                required=True,
+            ),
+            ParameterDefinition(
+                name="value_set",
+                label="Allowed Values",
+                type=ParameterType.STRING_LIST,
+                description="Set of allowed values",
+                required=True,
+            ),
+        ],
+        tags=["uniqueness", "set", "enum"],
+        severity_default="medium",
+    ),
+    ValidatorDefinition(
+        name="DistinctValuesEqualSet",
+        display_name="Distinct Values Equal Set",
+        category=ValidatorCategory.UNIQUENESS,
+        description="Validates that distinct values exactly match a specified set.",
+        parameters=[
+            ParameterDefinition(
+                name="column",
+                label="Column",
+                type=ParameterType.COLUMN,
+                required=True,
+            ),
+            ParameterDefinition(
+                name="value_set",
+                label="Expected Values",
+                type=ParameterType.STRING_LIST,
+                description="Exact set of expected values",
+                required=True,
+            ),
+        ],
+        tags=["uniqueness", "set", "exact"],
+        severity_default="medium",
+    ),
+    ValidatorDefinition(
+        name="DistinctValuesContainSet",
+        display_name="Distinct Values Contain Set",
+        category=ValidatorCategory.UNIQUENESS,
+        description="Ensures distinct values contain all elements of a specified set.",
+        parameters=[
+            ParameterDefinition(
+                name="column",
+                label="Column",
+                type=ParameterType.COLUMN,
+                required=True,
+            ),
+            ParameterDefinition(
+                name="required_values",
+                label="Required Values",
+                type=ParameterType.STRING_LIST,
+                description="Values that must be present",
+                required=True,
+            ),
+        ],
+        tags=["uniqueness", "set", "contains"],
+        severity_default="medium",
+    ),
+    ValidatorDefinition(
+        name="DistinctCountBetween",
+        display_name="Distinct Count Between",
+        category=ValidatorCategory.UNIQUENESS,
+        description="Validates that distinct count falls within a range.",
+        parameters=[
+            ParameterDefinition(
+                name="column",
+                label="Column",
+                type=ParameterType.COLUMN,
+                required=True,
+            ),
+            ParameterDefinition(
+                name="min_count",
+                label="Minimum Count",
+                type=ParameterType.INTEGER,
+                required=True,
+                min_value=0,
+            ),
+            ParameterDefinition(
+                name="max_count",
+                label="Maximum Count",
+                type=ParameterType.INTEGER,
+                required=True,
+                min_value=0,
+            ),
+        ],
+        tags=["uniqueness", "distinct", "range"],
+        severity_default="medium",
+    ),
+    ValidatorDefinition(
+        name="UniqueWithinRecord",
+        display_name="Unique Within Record",
+        category=ValidatorCategory.UNIQUENESS,
+        description="Ensures specified columns have unique values within each record.",
+        parameters=[
+            ParameterDefinition(
+                name="columns",
+                label="Columns",
+                type=ParameterType.COLUMN_LIST,
+                description="Columns to compare within each row",
+                required=True,
+            ),
+        ],
+        tags=["uniqueness", "row", "record"],
+        severity_default="medium",
+    ),
+    ValidatorDefinition(
+        name="AllColumnsUniqueWithinRecord",
+        display_name="All Columns Unique Within Record",
+        category=ValidatorCategory.UNIQUENESS,
+        description="Validates that all values within each record are unique.",
+        parameters=[
+            ParameterDefinition(
+                name="columns",
+                label="Columns",
+                type=ParameterType.COLUMN_LIST,
+                description="Columns to check (leave empty for all)",
+            ),
+        ],
+        tags=["uniqueness", "row", "all"],
+        severity_default="low",
+    ),
+    ValidatorDefinition(
+        name="NaturalKey",
+        display_name="Natural Key",
+        category=ValidatorCategory.UNIQUENESS,
+        description="Validates natural business key uniqueness (unique + meaningful).",
+        parameters=[
+            ParameterDefinition(
+                name="columns",
+                label="Key Columns",
+                type=ParameterType.COLUMN_LIST,
+                description="Columns forming the natural key",
+                required=True,
+            ),
+            ParameterDefinition(
+                name="allow_null",
+                label="Allow Null",
+                type=ParameterType.BOOLEAN,
+                description="Allow null values in key columns",
+                default=False,
+            ),
+        ],
+        tags=["uniqueness", "natural_key", "business"],
+        severity_default="high",
+    ),
+    ValidatorDefinition(
+        name="SurrogateKey",
+        display_name="Surrogate Key",
+        category=ValidatorCategory.UNIQUENESS,
+        description="Validates surrogate key properties (unique, non-null, sequential).",
+        parameters=[
+            ParameterDefinition(
+                name="column",
+                label="Surrogate Key Column",
+                type=ParameterType.COLUMN,
+                required=True,
+            ),
+            ParameterDefinition(
+                name="check_sequential",
+                label="Check Sequential",
+                type=ParameterType.BOOLEAN,
+                description="Verify keys are sequential without gaps",
+                default=False,
+            ),
+            ParameterDefinition(
+                name="start_value",
+                label="Start Value",
+                type=ParameterType.INTEGER,
+                description="Expected starting value",
+                default=1,
+            ),
+        ],
+        tags=["uniqueness", "surrogate_key", "identity"],
+        severity_default="critical",
+    ),
+]

truthound_dashboard/schemas/validators.py

@@ -0,0 +1,59 @@
+"""Validator configuration schemas.
+
+This module provides backward compatibility for the validators subpackage.
+All types and functions are re-exported from the validators module.
+
+For new code, prefer importing directly from truthound_dashboard.schemas.validators:
+
+    from truthound_dashboard.schemas.validators import (
+        VALIDATOR_REGISTRY,
+        ValidatorDefinition,
+        ValidatorConfig,
+        get_validator_by_name,
+    )
+"""
+
+from __future__ import annotations
+
+# Re-export all public symbols from the validators subpackage
+from truthound_dashboard.schemas.validators import (
+    # 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,
+)
+
+__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",
+]