table-validator 0.1.18__tar.gz → 0.1.20__tar.gz

{table_validator-0.1.18/table_validator.egg-info → table_validator-0.1.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: table-validator
-Version: 0.1.18
+Version: 0.1.20
 Summary: CLI tool for validating data migrations between Azure (Blob Storage / SQL Database) and Databricks Delta Lake catalogs
 License: MIT
 Requires-Python: >=3.9
@@ -135,6 +135,10 @@ Overall status: FAIL
 Tables: 1 total, 0 passed, 1 failed, 0 error, 0 skipped
 ```
 
+Call `validate_tables.help()` any time (no arguments, no live Spark
+connection needed) to print a full syntax reference for every keyword
+argument shown below, directly in the notebook cell.
+
 `result` also exposes each of the Excel report's own sheets as a
 plain-text table - print only the one you want:
 

{table_validator-0.1.18 → table_validator-0.1.20}/README.md

@@ -105,6 +105,10 @@ Overall status: FAIL
 Tables: 1 total, 0 passed, 1 failed, 0 error, 0 skipped
 ```
 
+Call `validate_tables.help()` any time (no arguments, no live Spark
+connection needed) to print a full syntax reference for every keyword
+argument shown below, directly in the notebook cell.
+
 `result` also exposes each of the Excel report's own sheets as a
 plain-text table - print only the one you want:
 

{table_validator-0.1.18 → table_validator-0.1.20}/table_validator/cli/main.py

@@ -124,14 +124,34 @@ def info() -> None:
         "  - Databricks catalog  -> Databricks catalog\n"
         "  - Azure Blob Storage  -> Databricks catalog\n"
         "  - Azure SQL Database  -> Databricks catalog\n"
+        "  - Azure Synapse SQL pool -> Databricks catalog\n"
         "\n"
         "Typical workflow, in order:\n"
         "\n"
         "  1. tablevalidator configure\n"
         "     Interactively set up credentials and which source/target "
         "table(s) to compare. Run this first, and again any time you "
-        "need to change settings (source type, tables, primary key, "
-        "which validations to run).\n"
+        "need to change settings.\n"
+        "     When a single source and target table are both named (not a "
+        "schema-wide sweep), the wizard also offers these optional steps "
+        "- answer 'no'/leave blank to skip any of them and keep today's "
+        "plain full-table comparison:\n"
+        "       - Primary key: a real key column for row-level comparison "
+        "instead of the ROW_NUMBER() fallback.\n"
+        "       - Customize column validation: compare ONLY specific "
+        "columns, SKIP specific columns entirely, or ignore datatype "
+        "mismatches on specific columns.\n"
+        "       - Filter to a subset of rows (Databricks source only): "
+        "restrict the whole comparison to rows matching a condition, e.g. "
+        "\"id > 10 and id < 30\" or \"gender = 'male'\" - either the same "
+        "condition on both sides, or a different one per side.\n"
+        "       - Map renamed columns (Databricks source only): pair up "
+        "individual columns that don't share a name between source and "
+        "target.\n"
+        "     When a schema is named on both sides but no specific table "
+        "is (a schema-wide sweep, Databricks source only), the wizard "
+        "instead offers to restrict the sweep to specific table names, or "
+        "map renamed tables (source name -> target name).\n"
         "\n"
         "  2. tablevalidator validate\n"
         "     Runs the comparison using the saved configuration and "

{table_validator-0.1.18 → table_validator-0.1.20}/table_validator/notebook.py

@@ -40,11 +40,12 @@ Typical usage, from a Databricks notebook cell:
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Set, Tuple
 
 import pandas as pd
 
 from table_validator.cli.summary_table import SummaryData, summary_from_response
+from table_validator.config.schema import ValidationType
 from table_validator.connectors.spark_connector import SparkConnector
 from table_validator.models import CatalogValidationRequest, CatalogValidationResponse
 from table_validator.reports.excel_report import (
@@ -285,6 +286,7 @@ def validate_tables(
     row_filter: Optional[str] = None,
     source_row_filter: Optional[str] = None,
     target_row_filter: Optional[str] = None,
+    enabled_validations: Optional[Set[ValidationType]] = None,
 ) -> ValidationResult:
     """
     Validate a source against a target, using the notebook's own ambient
@@ -355,6 +357,15 @@ def validate_tables(
     filtering every matched table by the same condition, e.g.
     `gender = 'male'`, is a legitimate use case).
 
+    `enabled_validations`, if given, restricts WHICH of the four check
+    groups run - a set of `ValidationType.CATALOG`/`SCHEMA`/`COLUMN`/`ROW`
+    (import from `table_validator.config.schema`). If omitted (the
+    default), all four run, identical to today's behavior. Mirrors the
+    CLI wizard's own "Which validations should run?" checkbox
+    (`ValidatorConfig.validations`) - e.g. pass
+    `{ValidationType.SCHEMA}` to check only schema/column shape without
+    ever comparing row counts or data.
+
     Returns a ValidationResult: `print(result)` alone shows a compact
     plain-text summary (no rich/box-drawing formatting, safe to print
     directly in a notebook cell, and correctly listing every table when
@@ -411,7 +422,7 @@ def validate_tables(
             "for a schema-wide sweep) - got a table on only one side."
         )
 
-    request = CatalogValidationRequest(
+    request_kwargs: Dict[str, Any] = dict(
         source_catalog=src_catalog,
         target_catalog=tgt_catalog,
         schemas=[src_schema],
@@ -423,11 +434,139 @@ def validate_tables(
         only_columns=only_columns,
         column_map=column_map or {},
         ignore_datatype_columns=ignore_datatype_columns or [],
-        # max_tier and enabled_validations deliberately left unset - the
-        # Pydantic model defaults already equal the CLI's own "full" mode
-        # (see this function's docstring above).
+        # max_tier deliberately left unset - the Pydantic model default
+        # already equals the CLI's own "full" mode (see this function's
+        # docstring above).
     )
+    if enabled_validations is not None:
+        request_kwargs["enabled_validations"] = enabled_validations
+    # else: leave enabled_validations unset - the Pydantic model default
+    # (all four ValidationType values) matches today's unchanged behavior.
+
+    request = CatalogValidationRequest(**request_kwargs)
 
     response = CatalogValidator(connector).compare_catalogs(request)
 
     return ValidationResult(response)
+
+
+# ---------------------------------------------------------------------------
+# validate_tables.help() - a code/notebook-usage reference, callable
+# directly on the function (`from table_validator import validate_tables;
+# validate_tables.help()`), separate from `tablevalidator info` (the CLI's
+# own usage reference, cli/main.py's info() command) - each covers only the
+# approach it belongs to, since a CLI-only user has no use for keyword-
+# argument syntax and a notebook-only user never touches config.yaml.
+# ---------------------------------------------------------------------------
+_HELP_TEXT = """
+validate_tables() - notebook-native table validation
+------------------------------------------------------
+Compares a source table against a target Databricks table (or every
+identically-named table across two schemas), from inside a Databricks
+notebook cell - no workspace URL, personal access token, or SQL Warehouse
+HTTP path to set up, since it reuses the notebook's own already-
+authenticated Spark session. Runs the exact same full-depth comparison
+engine as the `tablevalidator` CLI.
+
+Install and import:
+    %pip install table-validator
+    from table_validator import validate_tables
+
+Single-table comparison ("catalog.schema.table" on both sides):
+    result = validate_tables(
+        "catalog1.schema1.table1",
+        "catalog1.schema1.table2",
+    )
+
+Schema-wide sweep (no table named - "catalog.schema" on both sides):
+compares every identically-named table in that schema in one call:
+    result = validate_tables("catalog1.bronze", "catalog2.silver")
+
+    If some tables were renamed between source and target, pass table_map
+    (source name -> target name) - unmapped tables are still matched by
+    identical name as usual:
+        result = validate_tables(
+            "catalog1.bronze", "catalog2.silver",
+            table_map={"cust": "customers", "ord": "orders"},
+        )
+
+Keyword arguments (all optional):
+    primary_key            Real key column(s) for row-level comparison
+                            instead of the synthetic ROW_NUMBER() fallback.
+                            Single-table mode only.
+                                primary_key=["id"]
+    table_map               Renamed-table pairs, schema-wide sweep mode only.
+                                table_map={"cust": "customers"}
+    spark                    An explicit SparkSession, if you're not
+                             running inside an actual Databricks notebook
+                             (e.g. local development). Auto-detected
+                             otherwise.
+    ignore_columns           Columns excluded entirely from every check.
+                                ignore_columns=["updated_at"]
+    only_columns             If set, ONLY these columns (plus the primary
+                             key, if any) are compared.
+                                only_columns=["id", "name"]
+    column_map               Renamed-column pairs (source name -> target
+                             name), for a column that doesn't share a name
+                             between source and target.
+                                column_map={"cust_id": "customer_id"}
+    ignore_datatype_columns  Columns whose data-type mismatch is ignored -
+                             their other checks (nullable, statistics,
+                             row-hash) still run normally.
+                                ignore_datatype_columns=["legacy_flag"]
+    row_filter               Restrict comparison to rows matching a SQL
+                             WHERE-fragment, on BOTH sides - row count,
+                             statistics, fingerprint, and row-hash/column
+                             diff are all scoped to just the matching rows.
+                                row_filter="id > 20 and id < 100"
+                                row_filter="gender = 'male'"
+    source_row_filter        Like row_filter, but applied only to the
+    target_row_filter        source/target side respectively - combine
+                             with row_filter (ANDed) or use instead of it
+                             when the condition must differ per side.
+                                validate_tables(
+                                    "cat.sch.orders", "cat2.sch.orders",
+                                    source_row_filter="id > 20",
+                                    target_row_filter="id > 15",
+                                )
+                             Works in both single-table and schema-wide
+                             sweep mode. Each fragment is used as-is, not
+                             parsed or validated - a typo surfaces as a
+                             normal SQL error when the query runs.
+    enabled_validations      Restrict WHICH check groups run - a set of
+                             ValidationType.CATALOG/SCHEMA/COLUMN/ROW
+                             (import from table_validator.config.schema).
+                             Omitted = all four run, same as today.
+                                from table_validator.config.schema import ValidationType
+                                validate_tables(
+                                    "cat.sch.orders", "cat2.sch.orders",
+                                    enabled_validations={ValidationType.SCHEMA},
+                                )
+
+Reading the result:
+    print(result)                     Compact plain-text summary.
+    print(result.table_validation)    One row per table (Excel report's
+                                       "Table Validation" sheet).
+    print(result.column_validation)   One row per column.
+    print(result.data_mismatches)     One row per mismatched cell (needs a
+                                       real primary key or the row-number
+                                       fallback, FULL-depth detail only).
+    print(result.row_hash_mismatches) One row per mismatched primary key.
+    print(result.mismatch_categories) Root-cause breakdown (NULL_MISMATCH,
+                                       STRING_TRUNCATION, ...).
+    print(result.suggestions)         Plain-English fix suggestions.
+
+    Each of these is a small table object - .headers/.rows for
+    programmatic access, or .to_dataframe() for a real pandas DataFrame.
+    result.response is the raw CatalogValidationResponse for full
+    programmatic access beyond the sheet breakdown.
+
+Call validate_tables.help() any time to print this again.
+""".strip("\n")
+
+
+def _print_validate_tables_help() -> None:
+    print(_HELP_TEXT)
+
+
+validate_tables.help = _print_validate_tables_help

{table_validator-0.1.18 → table_validator-0.1.20/table_validator.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: table-validator
-Version: 0.1.18
+Version: 0.1.20
 Summary: CLI tool for validating data migrations between Azure (Blob Storage / SQL Database) and Databricks Delta Lake catalogs
 License: MIT
 Requires-Python: >=3.9
@@ -135,6 +135,10 @@ Overall status: FAIL
 Tables: 1 total, 0 passed, 1 failed, 0 error, 0 skipped
 ```
 
+Call `validate_tables.help()` any time (no arguments, no live Spark
+connection needed) to print a full syntax reference for every keyword
+argument shown below, directly in the notebook cell.
+
 `result` also exposes each of the Excel report's own sheets as a
 plain-text table - print only the one you want:
 

table_validator-0.1.20/table_validator.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.1.20",
+  "distance": 0,
+  "node": "g9124e37c7cb704b705524188c1a7fec5d1848039",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-09-08"
+}

{table_validator-0.1.18 → table_validator-0.1.20}/tests/test_cli.py

@@ -50,10 +50,14 @@ def test_info_command_describes_tool_and_workflow_order() -> None:
     result = runner.invoke(app, ["info"])
 
     assert result.exit_code == 0
-    # All three source types are named.
+    # All four source types are named.
     assert "Databricks catalog" in result.output
     assert "Azure Blob Storage" in result.output
     assert "Azure SQL Database" in result.output
+    assert "Synapse" in result.output
+    # Wizard customization steps are documented, including the row-filter
+    # feature.
+    assert "Filter to a subset of rows" in result.output
     # The three main commands appear in workflow order.
     configure_pos = result.output.index("tablevalidator configure")
     validate_pos = result.output.index("tablevalidator validate")

{table_validator-0.1.18 → table_validator-0.1.20}/tests/test_notebook.py

@@ -749,3 +749,76 @@ def test_row_filter_valid_in_schema_sweep_mode():
     fake_connector.set_row_filters.assert_called_once_with(
         common="gender = 'male'", source=None, target=None,
     )
+
+
+# ---------------------------------------------------------------------------
+# validate_tables.help() - a code/notebook-usage reference, separate from
+# the CLI's own `tablevalidator info` command.
+# ---------------------------------------------------------------------------
+def test_validate_tables_help_is_callable_and_prints_usage(capsys):
+    """validate_tables.help() must be reachable directly off the imported
+    function, print without requiring a SparkSession/Databricks connection,
+    and cover the keyword arguments a notebook user needs (row filters in
+    particular, the most recently added feature)."""
+    assert callable(validate_tables.help)
+
+    validate_tables.help()
+
+    captured = capsys.readouterr()
+    assert "validate_tables" in captured.out
+    assert "row_filter" in captured.out
+    assert "primary_key" in captured.out
+    assert "table_validation" in captured.out
+
+
+# ---------------------------------------------------------------------------
+# enabled_validations kwarg - restricts which of the 4 check groups run,
+# needed by tablevalidator-databricks' generated notebook (its checks
+# multiselect maps directly onto this).
+# ---------------------------------------------------------------------------
+def test_enabled_validations_omitted_keeps_default_all_four_types():
+    """Regression guard: NOT passing enabled_validations at all must
+    produce the exact same request as before this kwarg existed - the
+    Pydantic model's own default_factory (all four ValidationType values)
+    must still apply, not an empty set."""
+    from table_validator.config.schema import ValidationType
+
+    captured = {}
+
+    def fake_compare_catalogs(self, request):
+        captured["request"] = request
+        return _fake_response()
+
+    with patch("table_validator.notebook.SparkConnector", return_value=MagicMock()), \
+         patch(
+             "table_validator.notebook.CatalogValidator.compare_catalogs",
+             fake_compare_catalogs,
+         ):
+        validate_tables("cat1.sch1.t1", "cat1.sch1.t2", spark=MagicMock())
+
+    assert captured["request"].enabled_validations == {
+        ValidationType.CATALOG, ValidationType.SCHEMA,
+        ValidationType.COLUMN, ValidationType.ROW,
+    }
+
+
+def test_enabled_validations_passed_through_when_given():
+    from table_validator.config.schema import ValidationType
+
+    captured = {}
+
+    def fake_compare_catalogs(self, request):
+        captured["request"] = request
+        return _fake_response()
+
+    with patch("table_validator.notebook.SparkConnector", return_value=MagicMock()), \
+         patch(
+             "table_validator.notebook.CatalogValidator.compare_catalogs",
+             fake_compare_catalogs,
+         ):
+        validate_tables(
+            "cat1.sch1.t1", "cat1.sch1.t2", spark=MagicMock(),
+            enabled_validations={ValidationType.SCHEMA},
+        )
+
+    assert captured["request"].enabled_validations == {ValidationType.SCHEMA}

table_validator-0.1.18/table_validator.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "0.1.18",
-  "distance": 0,
-  "node": "g442d915637cacc0f99f5a1eb372c1cc7128f7e06",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-09-03"
-}