table-validator 0.1.0__py3-none-any.whl

table_validator/cli/partition_prompt.py

@@ -0,0 +1,78 @@
+"""
+Interactive partition-column prompt for `tablevalidator validate`.
+
+Invoked by CatalogValidator (validators/catalog_validator.py) via the
+optional partition_prompt callback, only for a table that is both large
+(row count over CatalogValidationRequest.partition_threshold) and has a
+confirmed mismatch (Tier 1 and/or Tier 2). The validator itself has no
+I/O - this module is the only place that actually talks to a human about
+which column to bucket by.
+
+build_partition_prompt() is the factory `cli/main.py` calls once per
+`validate` invocation; it captures --yes and TTY state so the returned
+callback can decide, on every call, whether to actually prompt or skip
+straight to "no partitioning" without ever risking a hang in a
+non-interactive/CI run.
+"""
+
+from __future__ import annotations
+
+import logging
+import sys
+from typing import Optional
+
+import questionary
+import typer
+
+from table_validator.models import PartitionPromptContext
+
+logger = logging.getLogger(__name__)
+
+_SKIP_LABEL = "Skip partitioning (compare the whole table)"
+
+
+def run_partition_prompt(context: PartitionPromptContext) -> Optional[str]:
+    """
+    Ask the user which column to partition/bucket by for a large,
+    confirmed-mismatched table, or let them skip. Returns the chosen
+    column name, or None if they chose to skip.
+    """
+    typer.echo(
+        f"\nTable '{context.schema_name}.{context.table}' has "
+        f"{context.row_count:,} rows and a confirmed mismatch. Comparing "
+        f"it row-by-row could be slow - partitioning first can narrow "
+        f"down which part of the table actually differs.",
+    )
+
+    choices = list(context.candidate_columns) + [_SKIP_LABEL]
+    answer = questionary.select(
+        "Partition by which column?",
+        choices=choices,
+    ).ask()
+
+    if answer is None or answer == _SKIP_LABEL:
+        return None
+    return answer
+
+
+def build_partition_prompt(yes: bool):
+    """
+    Factory for the callback passed to CatalogValidator(partition_prompt=...).
+
+    Returns None (meaning "never prompt, always fall back to unpartitioned
+    Tier 4") when --yes was passed or stdin isn't a real terminal - belt
+    and suspenders, so a non-interactive invocation can never hang on a
+    prompt even if --yes was forgotten.
+    """
+    if yes:
+        logger.debug("--yes passed - partition prompt disabled")
+        return None
+
+    if not sys.stdin.isatty():
+        logger.debug("stdin is not a TTY - partition prompt disabled")
+        return None
+
+    def _callback(context: PartitionPromptContext) -> Optional[str]:
+        return run_partition_prompt(context)
+
+    return _callback

table_validator/cli/summary_table.py

@@ -0,0 +1,146 @@
+"""
+Shared summary-table rendering, used by both `tablevalidator validate`
+(right after generating a report) and `tablevalidator report` (reading an
+existing one back). Both commands print the exact same aggregate figures
+that live on the Excel report's Summary sheet - overall status, per-table
+totals, pass percentage, and which validation types were run - so the
+console output and the file never disagree.
+
+SummaryData is the single shape both entry points build before handing
+off to print_summary_table(), so the rendering logic itself is never
+duplicated between the "just generated a live result" and "read an
+existing .xlsx back" cases.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+from openpyxl import load_workbook
+from rich.console import Console
+from rich.table import Table
+
+from table_validator.models import CatalogValidationResponse
+from table_validator.reports.excel_report import _build_summary_metrics
+
+
+@dataclass
+class SummaryData:
+    overall_status: str
+    total_tables: int
+    passed_tables: int
+    failed_tables: int
+    error_tables: int
+    skipped_tables: int
+    pass_percentage: str
+    source_type: Optional[str] = None
+    validations_run: Optional[str] = None
+    validation_timestamp: Optional[str] = None
+    duration_seconds: Optional[float] = None
+
+
+def summary_from_response(
+    result: CatalogValidationResponse,
+    source_type: Optional[str] = None,
+    validations_run: Optional[str] = None,
+) -> SummaryData:
+    """Build a SummaryData from a freshly-computed CatalogValidationResponse,
+    using the exact same _build_summary_metrics() the Excel Summary sheet
+    itself is built from - so the console table and the file always agree."""
+    metrics = dict(_build_summary_metrics(result))
+    return SummaryData(
+        overall_status=result.status.value,
+        total_tables=metrics["Total Tables"],
+        passed_tables=metrics["Passed Tables"],
+        failed_tables=metrics["Failed Tables"],
+        error_tables=metrics["Error Tables"],
+        skipped_tables=metrics["Skipped Tables"],
+        pass_percentage=metrics["Pass Percentage"],
+        source_type=source_type,
+        validations_run=validations_run,
+        validation_timestamp=result.validation_timestamp,
+        duration_seconds=result.execution_time_seconds,
+    )
+
+
+def summary_from_excel(path: Path) -> SummaryData:
+    """
+    Read a SummaryData back out of a saved report's Summary sheet.
+
+    The Summary sheet's row layout shifts depending on which optional
+    fields (Source Type, Validations Run) were present when it was
+    generated, so this scans column A for each known label by name
+    rather than assuming fixed row numbers.
+    """
+    wb = load_workbook(path, data_only=True, read_only=True)
+    try:
+        ws = wb["Summary"]
+
+        fields: dict = {}
+        for row in ws.iter_rows(min_col=1, max_col=2, values_only=True):
+            label, value = row[0], row[1]
+            if label is not None:
+                fields[str(label)] = value
+    finally:
+        # read_only workbooks hold an open file handle until closed -
+        # without this, a caller that immediately tries to overwrite or
+        # delete the same path (e.g. a subsequent `validate` run, or a
+        # test's tempdir cleanup) can hit a Windows file-lock error.
+        wb.close()
+
+    def _metric(label: str, default=0):
+        value = fields.get(label, default)
+        return int(value) if isinstance(value, (int, float)) else default
+
+    return SummaryData(
+        overall_status=str(fields.get("Overall Status", "UNKNOWN")),
+        total_tables=_metric("Total Tables"),
+        passed_tables=_metric("Passed Tables"),
+        failed_tables=_metric("Failed Tables"),
+        error_tables=_metric("Error Tables"),
+        skipped_tables=_metric("Skipped Tables"),
+        pass_percentage=str(fields.get("Pass Percentage", "0.00%")),
+        source_type=fields.get("Source Type"),
+        validations_run=fields.get("Validations Run"),
+        validation_timestamp=fields.get("Validation Timestamp") or None,
+        duration_seconds=fields.get("Duration (s)"),
+    )
+
+
+_STATUS_STYLES = {
+    "PASS": "bold green",
+    "FAIL": "bold red",
+    "ERROR": "bold yellow",
+    "SKIPPED": "bold white",
+}
+
+
+def print_summary_table(data: SummaryData, console: Optional[Console] = None) -> None:
+    """Render a SummaryData as a compact rich Table on the console."""
+    console = console or Console()
+
+    status_style = _STATUS_STYLES.get(data.overall_status, "bold white")
+
+    table = Table(title="Validation Summary", show_lines=False)
+    table.add_column("Metric", style="bold")
+    table.add_column("Value")
+
+    table.add_row("Overall Status", f"[{status_style}]{data.overall_status}[/{status_style}]")
+    if data.source_type:
+        table.add_row("Source Type", data.source_type)
+    if data.validations_run:
+        table.add_row("Validations Run", data.validations_run)
+    table.add_row("Total Tables", str(data.total_tables))
+    table.add_row("Passed Tables", f"[green]{data.passed_tables}[/green]")
+    table.add_row("Failed Tables", f"[red]{data.failed_tables}[/red]")
+    table.add_row("Error Tables", f"[yellow]{data.error_tables}[/yellow]")
+    table.add_row("Skipped Tables", str(data.skipped_tables))
+    table.add_row("Pass Percentage", data.pass_percentage)
+    if data.validation_timestamp:
+        table.add_row("Validation Timestamp", data.validation_timestamp)
+    if data.duration_seconds is not None:
+        table.add_row("Duration (s)", f"{data.duration_seconds:.3f}")
+
+    console.print(table)

table_validator/cli/wizard.py

@@ -0,0 +1,429 @@
+"""Interactive configuration wizard for `tablevalidator configure`.
+
+Walks the user through: what's being compared (source type), Databricks
+credentials (always needed - the target is always a Databricks catalog),
+source-specific credentials/scoping, target table details, and which
+validations to run. Non-secret answers are saved into ValidatorConfig via
+config/manager.py; secrets are written to ~/.table_validator/.env with
+owner-only file permissions.
+
+Phase 1 auth only: credentials are entered manually here and read back by
+auth/azure_auth.py and auth/databricks_auth.py. Nothing else in the
+codebase should read these credentials directly.
+
+Every free-text answer goes through _ask()/_ask_secret(), which strip()
+whitespace and normalize "" to None, so no field ever silently saves a
+value the user didn't actually type (this is also where the earlier
+' for_schema_validation' leading-space bug and the
+myserver.database.windows.net/mydb placeholder-default bug were fixed -
+both were free-text prompts that skipped this normalization).
+"""
+
+from __future__ import annotations
+
+import os
+import stat
+from pathlib import Path
+from typing import Dict, Optional
+
+import questionary
+import typer
+
+from table_validator.config.manager import CONFIG_PATH, load_config, save_config
+from table_validator.config.schema import SourceType, ValidationType, ValidatorConfig
+
+ENV_PATH = Path.home() / ".table_validator" / ".env"
+
+_ALL_VALIDATIONS = [
+    (ValidationType.CATALOG, "catalog"),
+    (ValidationType.SCHEMA, "schema"),
+    (ValidationType.COLUMN, "column"),
+    (ValidationType.ROW, "row"),
+]
+
+# Wizard-only convenience choice, not a ValidationType and never itself
+# stored in config.yaml - selecting it (alone or alongside individual
+# choices) resolves to the full validations list at answer time. See
+# _resolve_validation_selection().
+_ALL_LABEL = "All"
+
+# What's being compared, shown as the wizard's first question. Labels are
+# wizard-only display text; SourceType is what's actually stored.
+_SOURCE_TYPE_CHOICES = [
+    (SourceType.DATABRICKS, "Databricks catalog -> Databricks catalog"),
+    (SourceType.AZURE_BLOB, "Azure Blob Storage -> Databricks catalog"),
+    (SourceType.AZURE_SQL, "Azure SQL Database -> Databricks catalog"),
+]
+
+
+def _ask(prompt: questionary.Question) -> Optional[str]:
+    """
+    Resolve a questionary text/password prompt, stripping surrounding
+    whitespace and normalizing a blank answer to None.
+
+    This is the single choke point every free-text prompt in this wizard
+    goes through, specifically so "leave blank" and "stray whitespace"
+    are handled consistently everywhere instead of per-call-site (which
+    is how both bugs this fixes originally slipped through - one call
+    site normalized, the next one didn't).
+    """
+    answer = prompt.ask()
+    if answer is None:
+        return None
+    stripped = answer.strip()
+    return stripped or None
+
+
+def _prompt_table_ref(label: str, existing) -> Dict[str, Optional[str]]:
+    typer.echo(f"\n{label} table:")
+    catalog = _ask(questionary.text("  Catalog:", default=existing.catalog or ""))
+    schema_name = _ask(
+        questionary.text(
+            "  Schema (leave blank to compare all schemas in this catalog):",
+            default=existing.schema_name or "",
+        )
+    )
+    table = _ask(
+        questionary.text(
+            "  Table (leave blank to compare all tables in this schema):",
+            default=existing.table or "",
+        )
+    )
+    # Keyed by field name ("schema_name"), not the "schema" alias -
+    # model_copy(update=...) matches by field name and silently ignores
+    # unknown keys, so using the alias here would drop the schema value.
+    return {"catalog": catalog, "schema_name": schema_name, "table": table}
+
+
+def _prompt_primary_key(existing: Optional[list]) -> Optional[list]:
+    """
+    Optional primary/business key for the single named source/target
+    table - only asked when both are set to a specific table (not a
+    catalog-wide sweep). If left blank, row-level comparison falls back
+    to a synthetic ROW_NUMBER() match as before; a real key is cheaper
+    (no full-table sort) and avoids the row-number fallback's known
+    timeout risk on large tables.
+    """
+    default_str = ", ".join(existing) if existing else ""
+    answer = _ask(
+        questionary.text(
+            "Primary key column(s) for this table, comma-separated "
+            "(optional - leave blank to match rows by row-number instead):",
+            default=default_str,
+        )
+    )
+    if not answer:
+        return None
+    return [col.strip() for col in answer.split(",") if col.strip()]
+
+
+def _write_env_file(values: Dict[str, str], env_path: Optional[Path] = None) -> None:
+    """
+    Write secrets to env_path (default: ENV_PATH, resolved at call time)
+    as KEY=VALUE lines, restricted to owner read/write only. Only
+    non-empty values are written, so a step the user skipped doesn't
+    clobber a credential set in a previous run with an empty string.
+    """
+    env_path = env_path or ENV_PATH
+    env_path.parent.mkdir(parents=True, exist_ok=True)
+
+    existing: Dict[str, str] = {}
+    if env_path.exists():
+        for line in env_path.read_text(encoding="utf-8").splitlines():
+            if "=" in line and not line.strip().startswith("#"):
+                key, _, val = line.partition("=")
+                existing[key.strip()] = val
+
+    existing.update({k: v for k, v in values.items() if v})
+
+    content = "\n".join(f"{k}={v}" for k, v in existing.items()) + "\n"
+    env_path.write_text(content, encoding="utf-8")
+
+    # Owner read/write only (chmod 600). On Windows this is best-effort -
+    # NTFS ACLs don't map 1:1 onto POSIX mode bits, but os.chmod still
+    # clears the broadest "everyone" write/execute bits where supported.
+    try:
+        os.chmod(env_path, stat.S_IRUSR | stat.S_IWUSR)
+    except OSError:
+        pass
+
+
+def _normalize_workspace_url(url: str) -> str:
+    """Prepend https:// if the user typed a bare hostname."""
+    if not url.startswith(("https://", "http://")):
+        return f"https://{url}"
+    return url
+
+
+def _resolve_validation_selection(selected_labels):
+    """
+    Resolve the checkbox answer from the "Which validations should run?"
+    prompt into a deduplicated List[ValidationType].
+
+    "All" is a wizard-only convenience label, not a ValidationType - if
+    it's present (alone or alongside individual choices), the result is
+    always the full four-type list, regardless of what else was checked.
+    Otherwise, each selected label maps to its ValidationType, in
+    _ALL_VALIDATIONS order and with duplicates removed (checkbox answers
+    shouldn't contain duplicates, but this stays defensive either way).
+    """
+    label_to_type = {label: vtype for vtype, label in _ALL_VALIDATIONS}
+    selected = selected_labels or []
+
+    if _ALL_LABEL in selected:
+        return [vtype for vtype, _label in _ALL_VALIDATIONS]
+
+    resolved = [label_to_type[label] for label in selected if label in label_to_type]
+    # Preserve _ALL_VALIDATIONS order, drop duplicates.
+    return [vtype for vtype, _label in _ALL_VALIDATIONS if vtype in resolved]
+
+
+def _prompt_source_type(existing: SourceType) -> SourceType:
+    label_to_type = {label: stype for stype, label in _SOURCE_TYPE_CHOICES}
+    existing_label = next(
+        label for stype, label in _SOURCE_TYPE_CHOICES if stype == existing
+    )
+    answer = questionary.select(
+        "What are you comparing?",
+        choices=[label for _stype, label in _SOURCE_TYPE_CHOICES],
+        default=existing_label,
+    ).ask()
+    return label_to_type.get(answer, SourceType.DATABRICKS)
+
+
+def _prompt_databricks_credentials(config: ValidatorConfig, secrets: Dict[str, str]) -> None:
+    """Databricks credentials - always collected, since every source type
+    targets a Databricks catalog."""
+    typer.echo("\n== Databricks (target) ==")
+    workspace_url = _ask(
+        questionary.text(
+            "Databricks workspace URL (e.g. https://adb-123.databricks.net):",
+            default=config.databricks.workspace_url or "",
+        )
+    )
+    config.databricks.workspace_url = (
+        _normalize_workspace_url(workspace_url) if workspace_url else None
+    )
+    config.databricks.http_path = _ask(
+        questionary.text(
+            "Databricks SQL Warehouse HTTP path (e.g. /sql/1.0/warehouses/abc123):",
+            default=config.databricks.http_path or "",
+        )
+    )
+    token = _ask(questionary.password("Databricks personal access token:"))
+    if token:
+        secrets["DATABRICKS_TOKEN"] = token
+
+
+def _prompt_azure_ad_ids(config: ValidatorConfig) -> None:
+    """Optional tenant/subscription IDs, reserved for a future Service
+    Principal auth phase - relevant regardless of which Azure source (Blob
+    or SQL) is selected, so asked once rather than duplicated per branch."""
+    config.azure.tenant_id = _ask(
+        questionary.text(
+            "Azure AD tenant ID (optional, reserved for future Azure CLI / "
+            "Service Principal auth - leave blank to skip):",
+            default=config.azure.tenant_id or "",
+        )
+    )
+    config.azure.subscription_id = _ask(
+        questionary.text(
+            "Azure subscription ID (optional, leave blank to skip):",
+            default=config.azure.subscription_id or "",
+        )
+    )
+
+
+def _prompt_databricks_source(config: ValidatorConfig) -> None:
+    """source_type == databricks: source is another Databricks catalog,
+    same shape/prompts as the target."""
+    typer.echo("\n== Source table (Databricks) ==")
+    source = _prompt_table_ref("Source", config.source_table)
+    config.source_table = config.source_table.model_copy(update=source)
+
+
+def _prompt_azure_blob_source(config: ValidatorConfig, secrets: Dict[str, str]) -> None:
+    """source_type == azure_blob: Storage account/container/key, then
+    optional folder_prefix/file_pattern scoping which blobs are compared."""
+    typer.echo("\n== Azure Blob Storage (source) ==")
+    _prompt_azure_ad_ids(config)
+
+    config.azure.storage_account = _ask(
+        questionary.text(
+            "Azure Storage account name:",
+            default=config.azure.storage_account or "",
+        )
+    )
+    config.blob_source.container = _ask(
+        questionary.text(
+            "Container name:",
+            default=config.blob_source.container or config.azure.container or "",
+        )
+    )
+    # azure.container mirrors blob_source.container for backward
+    # compatibility with the Databricks-source-only AzureConfig shape.
+    config.azure.container = config.blob_source.container
+    storage_key = _ask(questionary.password("Azure Storage account key:"))
+    if storage_key:
+        secrets["AZURE_STORAGE_KEY"] = storage_key
+
+    config.blob_source.folder_prefix = _ask(
+        questionary.text(
+            "Folder prefix to scope blob discovery to "
+            "(leave blank to scan the whole container):",
+            default=config.blob_source.folder_prefix or "",
+        )
+    )
+    config.blob_source.file_pattern = _ask(
+        questionary.text(
+            "File pattern to scope blob discovery to, e.g. '*.csv' or "
+            "'*.parquet' (leave blank to consider every supported format):",
+            default=config.blob_source.file_pattern or "",
+        )
+    )
+    config.blob_source.blob_path = _ask(
+        questionary.text(
+            "Exact path to one specific source blob, e.g. "
+            "'n8ndirectory/customers.csv' (leave blank to match multiple "
+            "blobs by filename against catalog tables using folder_prefix/"
+            "file_pattern above instead). If set together with a Target "
+            "table name below, that exact blob and table are compared "
+            "directly, even if their names don't match:",
+            default=config.blob_source.blob_path or "",
+        )
+    )
+
+
+def _prompt_azure_sql_source(config: ValidatorConfig, secrets: Dict[str, str]) -> None:
+    """source_type == azure_sql: SQL server/database/credentials, then
+    optional schema/table scoping (blank = compare all, same convention
+    as the Databricks source/target prompts)."""
+    typer.echo("\n== Azure SQL Database (source) ==")
+    _prompt_azure_ad_ids(config)
+
+    config.azure.sql_server = _ask(
+        questionary.text(
+            "Azure SQL server:",
+            default=config.azure.sql_server or "",
+        )
+    )
+    config.azure.sql_database = _ask(
+        questionary.text(
+            "Azure SQL database name:",
+            default=config.azure.sql_database or "",
+        )
+    )
+    sql_username = _ask(questionary.text("Azure SQL username:"))
+    if sql_username:
+        secrets["AZURE_SQL_USERNAME"] = sql_username
+    sql_password = _ask(questionary.password("Azure SQL password:"))
+    if sql_password:
+        secrets["AZURE_SQL_PASSWORD"] = sql_password
+
+    config.sql_source.schema_name = _ask(
+        questionary.text(
+            "Schema (leave blank to compare all schemas in this database):",
+            default=config.sql_source.schema_name or "",
+        )
+    )
+    config.sql_source.table = _ask(
+        questionary.text(
+            "Table (leave blank to compare all tables in this schema):",
+            default=config.sql_source.table or "",
+        )
+    )
+
+
+def run_configure_wizard() -> None:
+    """Run the full interactive configuration wizard."""
+    if CONFIG_PATH.exists():
+        overwrite = questionary.confirm(
+            f"A config already exists at {CONFIG_PATH}. Overwrite it?",
+            default=False,
+        ).ask()
+        if not overwrite:
+            typer.echo("Cancelled. Existing configuration was not changed.")
+            raise typer.Exit(code=0)
+
+    config = load_config()
+    secrets: Dict[str, str] = {}
+
+    # ------------------------------------------------------------------
+    # 1. What's being compared
+    # ------------------------------------------------------------------
+    config.source_type = _prompt_source_type(config.source_type)
+
+    # ------------------------------------------------------------------
+    # 2. Databricks credentials - always needed (target is always
+    # Databricks); asked before branching so it's never duplicated below.
+    # ------------------------------------------------------------------
+    _prompt_databricks_credentials(config, secrets)
+
+    # ------------------------------------------------------------------
+    # 3. Source-specific credentials/scoping
+    # ------------------------------------------------------------------
+    if config.source_type == SourceType.AZURE_BLOB:
+        _prompt_azure_blob_source(config, secrets)
+    elif config.source_type == SourceType.AZURE_SQL:
+        _prompt_azure_sql_source(config, secrets)
+    else:
+        _prompt_databricks_source(config)
+
+    # ------------------------------------------------------------------
+    # 4. Target table (always Databricks, regardless of source_type)
+    # ------------------------------------------------------------------
+    typer.echo("\n== Target table (Databricks) ==")
+    target = _prompt_table_ref("Target", config.target_table)
+    config.target_table = config.target_table.model_copy(update=target)
+
+    # Primary key - only meaningful for a single specific table (both
+    # source and target named, not a catalog-wide sweep). Every source
+    # type's row-level comparison has the same synthetic-ROW_NUMBER()
+    # fallback and the same cost/timeout risk without a real key
+    # (databricks: source_table.table; azure_sql: sql_source.table;
+    # azure_blob: blob_source.blob_path), so this is asked whenever a
+    # specific table is named on both sides, not just for Databricks.
+    # Blank schema/table on either side means "compare many tables",
+    # which a single primary_key field can't represent.
+    if config.source_type == SourceType.AZURE_SQL:
+        source_table_named = bool(config.sql_source.table)
+    elif config.source_type == SourceType.AZURE_BLOB:
+        source_table_named = bool(config.blob_source.blob_path)
+    else:
+        source_table_named = bool(config.source_table.table)
+
+    if source_table_named and config.target_table.table:
+        config.primary_key = _prompt_primary_key(config.primary_key)
+    else:
+        config.primary_key = None
+
+    # ------------------------------------------------------------------
+    # 5. Validations to run
+    # ------------------------------------------------------------------
+    typer.echo("\n== Validations ==")
+    all_already_selected = set(config.validations) == {v for v, _label in _ALL_VALIDATIONS}
+    selected_labels = questionary.checkbox(
+        "Which validations should run?",
+        choices=[
+            questionary.Choice(_ALL_LABEL, checked=all_already_selected),
+            *[
+                questionary.Choice(label, checked=(vtype in config.validations))
+                for vtype, label in _ALL_VALIDATIONS
+            ],
+        ],
+    ).ask()
+    # "All" (alone or combined with individual choices) always resolves to
+    # the full set - it's a wizard convenience, never itself stored.
+    config.validations = _resolve_validation_selection(selected_labels)
+
+    # ------------------------------------------------------------------
+    # Persist
+    # ------------------------------------------------------------------
+    save_config(config)
+    _write_env_file(secrets)
+
+    typer.echo(f"\nConfiguration saved to {CONFIG_PATH}")
+    typer.echo(
+        "Credentials are stored in plaintext at ~/.table_validator/.env for now. "
+        "A future version will support Azure CLI / Databricks OAuth login."
+    )

table_validator/config/__init__.py

@@ -0,0 +1 @@
+"""Config package: schema definitions and load/save management for ~/.table_validator/."""