datacontract-cli 1.0.8__tar.gz → 1.0.10__tar.gz

{datacontract_cli-1.0.8/datacontract_cli.egg-info → datacontract_cli-1.0.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datacontract-cli
-Version: 1.0.8
+Version: 1.0.10
 Summary: The datacontract CLI is an open source command-line tool for working with Data Contracts. It uses data contract YAML files to lint the data contract, connect to data sources and execute schema and quality tests, detect breaking changes, and export to different formats. The tool is written in Python. It can be used as a standalone CLI tool, in a CI/CD pipeline, or directly as a Python library.
 Author-email: Jochen Christ <jochen.christ@innoq.com>, Stefan Negele <stefan.negele@innoq.com>, Simon Harrer <simon.harrer@innoq.com>
 License-Expression: MIT
@@ -15,6 +15,7 @@ Requires-Dist: typer<0.27,>=0.18.0
 Requires-Dist: click<9.0.0,>=8.1.0
 Requires-Dist: pydantic<2.14.0,>=2.8.2
 Requires-Dist: pyyaml~=6.0.1
+Requires-Dist: ruamel.yaml<0.19,>=0.17
 Requires-Dist: requests<2.35,>=2.31
 Requires-Dist: truststore<1.0,>=0.10
 Requires-Dist: fastjsonschema<2.22.0,>=2.19.1
@@ -41,7 +42,7 @@ Requires-Dist: openpyxl<4.0.0,>=3.1.5; extra == "excel"
 Provides-Extra: databricks
 Requires-Dist: ibis-framework[databricks,pyspark]<13.0.0,>=10.0.0; extra == "databricks"
 Requires-Dist: databricks-sql-connector<4.4.0,>=3.7.0; extra == "databricks"
-Requires-Dist: databricks-sdk<0.119.0; extra == "databricks"
+Requires-Dist: databricks-sdk<0.121.0; extra == "databricks"
 Requires-Dist: pyspark<5.0.0,>=3.5.0; extra == "databricks"
 Provides-Extra: iceberg
 Requires-Dist: pyiceberg==0.11.1; extra == "iceberg"
@@ -67,7 +68,7 @@ Requires-Dist: duckdb-extension-httpfs<1.6.0,>=1.5.0; extra == "gcs"
 Provides-Extra: azure
 Requires-Dist: datacontract-cli[duckdb]; extra == "azure"
 Requires-Dist: duckdb-extension-azure<1.6.0,>=1.5.0; extra == "azure"
-Requires-Dist: azure-identity<1.18,>=1.17.1; extra == "azure"
+Requires-Dist: azure-identity<1.26,>=1.17.1; extra == "azure"
 Requires-Dist: azure-storage-blob<12.31,>=12.24; extra == "azure"
 Provides-Extra: snowflake
 Requires-Dist: snowflake-connector-python[pandas]<4.7,>=3.6; extra == "snowflake"
@@ -92,8 +93,8 @@ Requires-Dist: pyarrow>=18.1.0; extra == "parquet"
 Provides-Extra: rdf
 Requires-Dist: rdflib==7.6.0; extra == "rdf"
 Provides-Extra: api
-Requires-Dist: fastapi<0.139.0,>=0.115.0; extra == "api"
-Requires-Dist: uvicorn<0.50.0,>=0.44.0; extra == "api"
+Requires-Dist: fastapi<0.140.0,>=0.115.0; extra == "api"
+Requires-Dist: uvicorn<0.51.0,>=0.44.0; extra == "api"
 Provides-Extra: protobuf
 Requires-Dist: proto-schema-parser<3.0,>=1.0; extra == "protobuf"
 Provides-Extra: all
@@ -111,9 +112,9 @@ Requires-Dist: pytest-xdist; extra == "dev"
 Requires-Dist: pymssql==2.3.13; extra == "dev"
 Requires-Dist: psycopg2-binary<3.0,>=2.9; extra == "dev"
 Requires-Dist: mysql-connector-python<9.7.0,>=8.0.30; extra == "dev"
-Requires-Dist: ruff==0.15.18; extra == "dev"
+Requires-Dist: ruff==0.15.20; extra == "dev"
 Requires-Dist: testcontainers[kafka,minio,mssql,mysql,postgres]==4.14.2; extra == "dev"
-Requires-Dist: trino==0.337.0; extra == "dev"
+Requires-Dist: trino==0.338.0; extra == "dev"
 Dynamic: license-file
 
 # Data Contract CLI
@@ -249,8 +250,10 @@ $ datacontract changelog v1.odcs.yaml v2.odcs.yaml
 # execute schema and quality checks (define credentials as environment variables)
 $ datacontract test odcs.yaml
 
-# generate dbt tests from a contract into your dbt project and run `dbt test`
+# generate dbt tests from a contract into your dbt project, then run them
+# (omit the contract to sync/test every *.odcs.yaml in the project)
 $ datacontract dbt sync orders.odcs.yaml --project-dir ./warehouse
+$ datacontract dbt test orders.odcs.yaml --project-dir ./warehouse
 
 # export data contract as html (other formats: avro, dbt-models, dbt-sources, dbt-staging-sql, jsonschema, odcs, rdf, sql, sodacl, terraform, ...)
 $ datacontract export html datacontract.yaml --output odcs.html

{datacontract_cli-1.0.8 → datacontract_cli-1.0.10}/README.md

@@ -131,8 +131,10 @@ $ datacontract changelog v1.odcs.yaml v2.odcs.yaml
 # execute schema and quality checks (define credentials as environment variables)
 $ datacontract test odcs.yaml
 
-# generate dbt tests from a contract into your dbt project and run `dbt test`
+# generate dbt tests from a contract into your dbt project, then run them
+# (omit the contract to sync/test every *.odcs.yaml in the project)
 $ datacontract dbt sync orders.odcs.yaml --project-dir ./warehouse
+$ datacontract dbt test orders.odcs.yaml --project-dir ./warehouse
 
 # export data contract as html (other formats: avro, dbt-models, dbt-sources, dbt-staging-sql, jsonschema, odcs, rdf, sql, sodacl, terraform, ...)
 $ datacontract export html datacontract.yaml --output odcs.html

{datacontract_cli-1.0.8 → datacontract_cli-1.0.10}/datacontract/cli.py

@@ -25,6 +25,7 @@ COMMAND_ORDER = [
     "edit",
     "lint",
     "changelog",
+    "sync",  # `dbt sync` subcommand; no top-level `sync`, so this only orders the dbt group
     "test",
     "ci",
     "export",

datacontract_cli-1.0.10/datacontract/command_dbt.py

@@ -0,0 +1,531 @@
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+import typer
+from open_data_contract_standard.model import OpenDataContractStandard
+from typing_extensions import Annotated
+
+from datacontract.cli import (
+    OrderedCommandsWithMigrationHints,
+    console,
+    debug_option,
+    enable_debug_logging,
+    validate_publish_url,
+)
+from datacontract.integration.dbt_sync import (
+    ModelResolution,
+    _ensure_dbt_project,
+    _is_odcs_file,
+    _resolve_contract_paths,
+    check_dbt_on_path,
+    generate_dbt_tests,
+    parse_dbt_test_run,
+    parse_filename_version,
+    resolve_model_names,
+    resolve_versioned_target,
+    run_dbt_test,
+)
+from datacontract.integration.entropy_data import publish_test_results_to_entropy_data
+from datacontract.lint.resolve import resolve_data_contract
+from datacontract.model.run import ResultEnum, Run
+from datacontract.output.test_results_writer import print_test_results_table, to_field
+
+dbt_app = typer.Typer(cls=OrderedCommandsWithMigrationHints, no_args_is_help=True)
+
+_RESULT_EMOJI = {
+    ResultEnum.passed: "🟢",
+    ResultEnum.warning: "🟠",
+    ResultEnum.failed: "🔴",
+    ResultEnum.error: "🔴",
+}
+
+
+@dataclass
+class _ContractCtx:
+    """One contract resolved for a `dbt test` run (shared across sync's run path and `dbt test`)."""
+
+    contract_path: Path
+    odcs: OpenDataContractStandard
+    model_names: list[str]  # effective dbt model names — drive selection and result attribution
+    generation_run: Optional[Run]  # set on sync's --run-tests path, None on `dbt test`
+    dbt_version: Optional[str] = None  # filename-derived dbt model version, when this contract is versioned
+
+
+@dataclass
+class _Owner:
+    path: Path
+    contract_id: Optional[str]
+    contract_version: str
+    dbt_version: Optional[str]  # filename-derived version, None if the contract can't map to one
+
+
+def _check_model_ownership(owners_by_model: dict) -> None:
+    """Hard-error unless every model shared by multiple contracts is a clean version group.
+
+    A shared model is allowed only when its owners are versions of the *same* contract: one
+    `odcs.id`, distinct `version`s, and each with a filename `v<N>` that maps to a dbt model version.
+    """
+    errors: list[str] = []
+    for model, owners in owners_by_model.items():
+        if len(owners) < 2:
+            continue
+        ids = {o.contract_id for o in owners}
+        versions = [o.contract_version for o in owners]
+        if len(ids) > 1:
+            listed = ", ".join(f"{o.path.name} ({o.contract_id})" for o in owners)
+            errors.append(
+                f"  - `{model}` is claimed by different contracts. If those are versions of the same contract, make sure they have the same ID: {listed}"
+            )
+        elif len(set(versions)) != len(versions):
+            errors.append(f"  - `{model}`: Two contracts share ID `{next(iter(ids))}` and version `{versions[0]}`.")
+        elif any(o.dbt_version is None for o in owners):
+            listed = ", ".join(o.path.name for o in owners if o.dbt_version is None)
+            errors.append(
+                f"  - `{model}` is claimed by different contracts. If those are versions of the same contract, "
+                f"rename the files to contain the version number followed by the letter `v`, e.g. `my-contract-v1.odcs.yaml`: {listed}"
+            )
+    if errors:
+        console.print("[red]Cannot sync — overlapping dbt models:\n" + "\n".join(errors) + "[/red]")
+        raise typer.Exit(code=1)
+
+
+def _validate_server_declared(odcs, server: Optional[str]) -> None:
+    """Reject a `--server` that the contract doesn't declare."""
+    if server is None:
+        return
+    known = [s.server for s in odcs.servers or [] if s.server]
+    if server not in known:
+        console.print(
+            f"[red]--server {server!r} is not declared in the contract. Available: {', '.join(known) or '(none)'}[/red]"
+        )
+        raise typer.Exit(code=1)
+
+
+def _maybe_publish(run: Run, odcs, publish: Optional[str], ssl_verification: bool) -> bool:
+    """Publish the run if requested; return True if a publish was attempted and failed."""
+    if publish is None:
+        return False
+    if run.server is None:
+        if not odcs.servers:
+            console.print(
+                "[yellow]Skipping publish: the contract declares no servers. "
+                "Add a `servers:` block to identify the run.[/yellow]"
+            )
+        else:
+            known = ", ".join(s.server for s in odcs.servers if s.server) or "(none)"
+            console.print(
+                f"[yellow]Skipping publish: the contract declares multiple servers ({known}). "
+                f"Pass --server to identify the run.[/yellow]"
+            )
+        return False
+    return not publish_test_results_to_entropy_data(run, publish, ssl_verification)
+
+
+def _report_run(run: Run, *, run_only: bool, publish_failed: bool, ctx: _ContractCtx) -> bool:
+    """Print one contract's results; return True if it should fail the invocation."""
+    console.print(f"\n[bold]Contract {run.dataContractId}@{run.dataContractVersion}[/bold] — {ctx.contract_path}")
+    if not run.checks:
+        if run_only:
+            console.print(
+                "[yellow]No managed tests found. Run `datacontract dbt sync` first to "
+                "generate tests from your contract.[/yellow]"
+            )
+        else:
+            console.print("[yellow]No tests ran for this contract.[/yellow]")
+        return publish_failed
+
+    print_test_results_table(run, console)
+    total = len(run.checks)
+    took = (run.timestampEnd - run.timestampStart).total_seconds()
+    if run.result == ResultEnum.passed:
+        console.print(f"🟢 dbt tests passed. Ran {total} tests. Took {took} seconds.")
+        return publish_failed
+    if run.result == ResultEnum.warning:
+        console.print("🟠 dbt tests have warnings:")
+    else:
+        console.print("🔴 dbt tests failed, found the following errors:")
+    i = 1
+    for check in run.checks:
+        if check.result not in (None, ResultEnum.passed):
+            field = to_field(run, check)
+            prefix = f"{field} " if field else ""
+            console.print(f"{i}) {prefix}{check.name}: {check.reason}")
+            i += 1
+    return run.result in (ResultEnum.failed, ResultEnum.error) or publish_failed
+
+
+def _rel(path: Path, project_dir: Path) -> str:
+    try:
+        return str(path.relative_to(project_dir))
+    except ValueError:
+        return str(path)
+
+
+def _count(n: int, noun: str) -> str:
+    return f"{n} {noun}" + ("" if n == 1 else "s")
+
+
+# List filenames individually up to this many; beyond it, truncate with "... and N more".
+_MAX_LISTED_FILES = 5
+
+
+def _print_sync_summary(gen, project_dir: Path, *, debug: bool = False) -> None:
+    """Print the per-contract sync summary, naming the touched files."""
+    prefix = f"{gen.contract_path.name}: "
+    line = f"{prefix}Synced {_count(len(gen.resolved_models), 'model')}: updated {_count(len(gen.written_yaml), 'YAML file')}"
+    if gen.written_sql:
+        line += f", wrote {_count(len(gen.written_sql), 'singular SQL test')}"
+    if gen.deleted_files:
+        line += f", removed {_count(len(gen.deleted_files), 'YAML file')}"
+    console.print(line + ".")
+
+    entries = (
+        [f"~ {_rel(p, project_dir)}" for p in gen.written_yaml]
+        + [f"+ {_rel(p, project_dir)}" for p in gen.written_sql]
+        + [f"- {_rel(p, project_dir)}" for p in gen.deleted_files]
+    )
+    shown = entries if debug else entries[:_MAX_LISTED_FILES]
+    for entry in shown:
+        console.print(f"  {entry}")
+    if len(entries) > len(shown):
+        console.print(f"  ... and {len(entries) - len(shown)} more [dim](pass --debug to show all)[/dim]")
+
+
+def _warn_prunable(gen, project_dir: Path) -> None:
+    """Warn that the project has contract-absent columns/tags `--prune` would remove (it wasn't passed)."""
+    if not gen.prunable:
+        return
+    prefix = f"{gen.contract_path.name}: "
+    shown = gen.prunable[:_MAX_LISTED_FILES]
+    console.print(
+        f"[yellow]{prefix}{_count(len(gen.prunable), 'item')} in the project "
+        f"{'is' if len(gen.prunable) == 1 else 'are'} not declared in the contract; "
+        "pass --prune to remove:[/yellow]"
+    )
+    for item in shown:
+        console.print(f"[yellow]  - {item}[/yellow]")
+    if len(gen.prunable) > len(shown):
+        console.print(f"[yellow]  ... and {len(gen.prunable) - len(shown)} more[/yellow]")
+
+
+def _run_and_report(
+    ctxs: list[_ContractCtx],
+    project_dir: Path,
+    *,
+    target: Optional[str],
+    profiles_dir: Optional[Path],
+    publish: Optional[str],
+    server: Optional[str],
+    ssl_verification: bool,
+    error_rows: list[tuple[Path, str]],
+    multiple_contracts: bool,
+) -> bool:
+    """Run `dbt test` once (scoped to all requested contracts' models), then report per contract.
+
+    Returns True if the invocation should exit non-zero.
+    """
+    model_versions = sorted(
+        {(m, c.dbt_version, str(c.odcs.version or "no_version")) for c in ctxs for m in c.model_names},
+        key=lambda t: (t[0], t[1] or "", t[2]),
+    )
+    if model_versions:
+        completed = run_dbt_test(project_dir, target=target, profiles_dir=profiles_dir, model_versions=model_versions)
+    else:
+        completed = subprocess.CompletedProcess(args=[], returncode=0, stdout="", stderr="")
+
+    any_failed = bool(error_rows)
+    footer: list[tuple[str, str, str]] = []
+    for c in ctxs:
+        model_filter: set[str] = {m.lower() for m in c.model_names}
+        run = parse_dbt_test_run(
+            project_dir, c.odcs, completed, model_filter=model_filter, generation_run=c.generation_run
+        )
+        if server is not None:
+            run.server = server
+        elif c.odcs.servers and len(c.odcs.servers) == 1:
+            run.server = c.odcs.servers[0].server
+        else:
+            run.server = target
+        publish_failed = _maybe_publish(run, c.odcs, publish, ssl_verification)
+        failed = _report_run(
+            run,
+            run_only=(c.generation_run is None),
+            publish_failed=publish_failed,
+            ctx=c,
+        )
+        any_failed = any_failed or failed
+        label = f"{run.dataContractId}@{run.dataContractVersion}"
+        if not run.checks:
+            footer.append(("⚪", label, "no tests"))
+        else:
+            footer.append((_RESULT_EMOJI.get(run.result, "🔴"), label, run.result.value))
+
+    for path, msg in error_rows:
+        console.print(f"[red]🔴 {path}: {msg}[/red]")
+        footer.append(("🔴", str(path), "error"))
+
+    if multiple_contracts:
+        # Render the per-contract status block + tally.
+        console.print("\n[bold]Contract results:[/bold]")
+        for emoji, label, status in footer:
+            console.print(f"  {emoji} {label} — {status}")
+        tally = {}
+        for _, _, status in footer:
+            tally[status] = tally.get(status, 0) + 1
+        summary = " · ".join(f"{n} {status}" for status, n in tally.items())
+        console.print(f"Tested {len(footer)} contract(s): {summary}.")
+    return any_failed
+
+
+@dbt_app.command(
+    name="sync",
+    epilog="Example: datacontract dbt sync orders.odcs.yaml --project-dir ./warehouse",
+)
+def sync_command(
+    contract: Annotated[
+        Optional[list[str]],
+        typer.Argument(
+            help="Path(s) or glob(s) of ODCS contracts to sync. If omitted, syncs every `*.odcs.yaml` "
+            "under --project-dir (default: current directory) and its subdirectories.",
+        ),
+    ] = None,
+    project_dir: Annotated[
+        Optional[Path],
+        typer.Option(
+            help="Path to the dbt project root (must contain `dbt_project.yml`). Defaults to the current directory."
+        ),
+    ] = None,
+    schema_name: Annotated[
+        str,
+        typer.Option(help="Which ODCS schema object to sync, by name."),
+    ] = "all",
+    model_resolution: Annotated[
+        ModelResolution,
+        typer.Option(help="How to map an ODCS schema to a dbt model name."),
+    ] = ModelResolution.name,
+    target: Annotated[Optional[str], typer.Option(help="Forwarded to `dbt test --target`.")] = None,
+    profiles_dir: Annotated[
+        Optional[Path],
+        typer.Option(help="Forwarded to `dbt test --profiles-dir`."),
+    ] = None,
+    prune: Annotated[
+        bool,
+        typer.Option(help="Remove model columns and tags that are not declared in the contract."),
+    ] = False,
+    run_tests_flag: Annotated[
+        bool,
+        typer.Option(
+            "--run-tests/--skip-tests",
+            help="Run `dbt test` on the generated tests after syncing. Default: skip (generate only).",
+        ),
+    ] = False,
+    publish: Annotated[Optional[str], typer.Option(help="The url to publish the results after the test.")] = None,
+    server: Annotated[
+        Optional[str],
+        typer.Option(
+            help="Selected ODCS server. Determines the dialect for data types and for the server label when publishing results. Default: Auto-selected if only one server exists, else --target.",
+        ),
+    ] = None,
+    ssl_verification: Annotated[bool, typer.Option(help="SSL verification when publishing test results.")] = True,
+    debug: debug_option = None,
+):
+    """
+    Generate dbt tests and model metadata from one or more ODCS contracts.
+
+    Modifies the existing dbt model YAML in place (preserving comments and formatting), and creates new model YAML files
+    or singular SQL tests if needed. Use `datacontract dbt test` or pass --run-tests to run the generated tests.
+    """
+    enable_debug_logging(debug)
+    validate_publish_url(publish)
+
+    if publish is not None and not run_tests_flag:
+        console.print("[red]--publish requires --run-tests.[/red]")
+        raise typer.Exit(code=1)
+
+    explicit_project_dir = project_dir is not None
+    project_dir = (project_dir or Path.cwd()).resolve()
+    _ensure_dbt_project(project_dir, explicit=explicit_project_dir)
+    paths = _resolve_contract_paths(contract or [], project_dir)
+    if paths and not any(_is_odcs_file(p) for p in paths):
+        console.print("[red]None of the passed contracts are valid ODCS data contracts.[/red]")
+        raise typer.Exit(code=1)
+    multiple_contracts = len(paths) > 1
+
+    # Load + resolve models for the ownership pre-flight, before any contract writes to disk.
+    loaded: list[tuple[Path, object, list[str], Optional[str]]] = []
+    error_rows: list[tuple[Path, str]] = []
+    owners_by_model: dict = {}
+    for path in paths:
+        if not _is_odcs_file(path):
+            console.print(f"[yellow]Skipping {path}: not an ODCS data contract.[/yellow]")
+            continue
+        try:
+            odcs = resolve_data_contract(str(path))
+            model_names = list(resolve_model_names(odcs, model_resolution, schema_name).values())
+            dbt_version = resolve_versioned_target(project_dir, model_names, parse_filename_version(path))
+            loaded.append((path, odcs, model_names, dbt_version))
+            for model in {m.lower() for m in model_names}:
+                owners_by_model.setdefault(model, []).append(
+                    _Owner(path, odcs.id, odcs.version or "no_version", dbt_version)
+                )
+        except Exception as e:
+            if not multiple_contracts:
+                raise
+            error_rows.append((path, str(e)))
+    _check_model_ownership(owners_by_model)
+    for _, odcs, _, _ in loaded:
+        _validate_server_declared(odcs, server)
+
+    ctxs: list[_ContractCtx] = []
+    for path, odcs, _, dbt_version in loaded:
+        try:
+            gen = generate_dbt_tests(
+                contract=str(path),
+                project_dir=project_dir,
+                schema_name=schema_name,
+                model_resolution=model_resolution,
+                prune=prune,
+                model_version=dbt_version,
+                server=server,
+            )
+        except Exception as e:
+            if not multiple_contracts:
+                raise
+            error_rows.append((path, str(e)))
+            continue
+        if not contract and not multiple_contracts:
+            console.print(f"Resolved contract {gen.contract_path}")
+        _print_sync_summary(gen, project_dir, debug=bool(debug))
+        if not prune:
+            _warn_prunable(gen, project_dir)
+        ctxs.append(_ContractCtx(gen.contract_path, gen.odcs, gen.resolved_models, gen.generation_run, dbt_version))
+
+    if not run_tests_flag:
+        console.print("[dim]Run `datacontract dbt test` to execute the generated tests.[/dim]")
+        for path, msg in error_rows:
+            console.print(f"[red]🔴 {path}: {msg}[/red]")
+        if error_rows:
+            raise typer.Exit(code=1)
+        return
+
+    check_dbt_on_path()
+    failed = _run_and_report(
+        ctxs,
+        project_dir,
+        target=target,
+        profiles_dir=profiles_dir,
+        publish=publish,
+        server=server,
+        ssl_verification=ssl_verification,
+        error_rows=error_rows,
+        multiple_contracts=multiple_contracts,
+    )
+    if failed:
+        raise typer.Exit(code=1)
+
+
+@dbt_app.command(
+    name="test",
+    epilog="Example: datacontract dbt test orders.odcs.yaml --project-dir ./warehouse",
+)
+def test_command(
+    contract: Annotated[
+        Optional[list[str]],
+        typer.Argument(
+            help="Path(s) or glob(s) of ODCS contracts to test. If omitted, tests every `*.odcs.yaml` "
+            "under --project-dir (default: current directory) and its subdirectories.",
+        ),
+    ] = None,
+    project_dir: Annotated[
+        Optional[Path],
+        typer.Option(
+            help="Path to the dbt project root (must contain `dbt_project.yml`). Defaults to the current directory."
+        ),
+    ] = None,
+    target: Annotated[Optional[str], typer.Option(help="Forwarded to `dbt test --target`.")] = None,
+    profiles_dir: Annotated[
+        Optional[Path],
+        typer.Option(help="Forwarded to `dbt test --profiles-dir`."),
+    ] = None,
+    publish: Annotated[Optional[str], typer.Option(help="The url to publish the results after the test.")] = None,
+    server: Annotated[
+        Optional[str],
+        typer.Option(
+            help="Selected ODCS server, used as the server label when publishing results. Default: Auto-selected if only one server exists, else --target.",
+        ),
+    ] = None,
+    ssl_verification: Annotated[bool, typer.Option(help="SSL verification when publishing test results.")] = True,
+    debug: debug_option = None,
+):
+    """
+    Run the contract-managed dbt tests that `datacontract dbt sync` generated.
+
+    Runs `dbt test` scoped to the specified data contract(s), reports the results, and optionally publishes
+    them. Use `datacontract dbt sync` to create and update the tests first.
+    """
+    enable_debug_logging(debug)
+    validate_publish_url(publish)
+    check_dbt_on_path()
+
+    explicit_project_dir = project_dir is not None
+    project_dir = (project_dir or Path.cwd()).resolve()
+    _ensure_dbt_project(project_dir, explicit=explicit_project_dir)
+    paths = _resolve_contract_paths(contract or [], project_dir)
+    multiple_contracts = len(paths) > 1
+
+    ctxs: list[_ContractCtx] = []
+    error_rows: list[tuple[Path, str]] = []
+    owners_by_model: dict = {}
+    skipped: list[Path] = []
+    for path in paths:
+        if not _is_odcs_file(path):
+            skipped.append(path)
+            continue
+        try:
+            odcs = resolve_data_contract(str(path))
+        except Exception as e:
+            if not multiple_contracts:
+                raise
+            error_rows.append((path, str(e)))
+            continue
+        if not contract and not multiple_contracts:
+            console.print(f"Resolved contract {path}")
+        # `dbt test` doesn't know which `--model-resolution` `dbt sync` used, so match on both name and physicalName.
+        model_names: list[str] = []
+        for s in odcs.schema_ or []:
+            if s.name:
+                model_names.append(s.name)
+            if getattr(s, "physicalName", None):
+                model_names.append(s.physicalName)
+        dbt_version = resolve_versioned_target(project_dir, model_names, parse_filename_version(path))
+        ctxs.append(_ContractCtx(path, odcs, model_names, None, dbt_version))
+        for model in {m.lower() for m in model_names}:
+            owners_by_model.setdefault(model, []).append(
+                _Owner(path, odcs.id, odcs.version or "no_version", dbt_version)
+            )
+
+    if paths and not ctxs and not error_rows:
+        console.print("[red]None of the passed contracts are valid ODCS data contracts.[/red]")
+        raise typer.Exit(code=1)
+    for path in skipped:
+        console.print(f"[yellow]Skipping {path}: not an ODCS data contract.[/yellow]")
+
+    _check_model_ownership(owners_by_model)
+    for c in ctxs:
+        _validate_server_declared(c.odcs, server)
+
+    failed = _run_and_report(
+        ctxs,
+        project_dir,
+        target=target,
+        profiles_dir=profiles_dir,
+        publish=publish,
+        server=server,
+        ssl_verification=ssl_verification,
+        error_rows=error_rows,
+        multiple_contracts=multiple_contracts,
+    )
+    if failed:
+        raise typer.Exit(code=1)

{datacontract_cli-1.0.8 → datacontract_cli-1.0.10}/datacontract/engines/checks/check_spec.py

@@ -29,6 +29,7 @@ class MetricType(str, Enum):
     INVALID_COUNT = "invalid_count"
     FIELD_PRESENT = "field_present"
     FIELD_TYPE = "field_type"
+    FIELD_PHYSICAL_TYPE = "field_physical_type"
     FRESHNESS = "freshness"
     RETENTION = "retention"
     CUSTOM_SQL = "custom_sql"
@@ -122,6 +123,7 @@ class CheckSpec:
     expected_category: Optional[str] = None  # FIELD_TYPE: human-readable label (display only)
     expected_type_label: Optional[str] = None  # FIELD_TYPE: human-readable expected type
     expected_schema_property: Optional["SchemaProperty"] = None  # FIELD_TYPE: structural comparison
+    expected_physical_type: Optional[str] = None  # FIELD_PHYSICAL_TYPE: contract physicalType
 
     columns: Optional[List[str]] = None  # DUPLICATE_COUNT across multiple columns