contractforge-databricks 0.1.0__py3-none-any.whl

contractforge_databricks/environment.py

@@ -0,0 +1,53 @@
+"""Databricks interpretation of the core environment contract."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from contractforge_core.contracts import validate_environment_contract
+from contractforge_databricks.coercion import mapping
+
+
+@dataclass(frozen=True)
+class DatabricksEnvironment:
+    name: str = "dev"
+    evidence_catalog: str = "main"
+    evidence_schema: str = "ops"
+    workspace_path: str = "/Workspace/ContractForge"
+    bundle_target: str = "dev"
+    runtime_kind: str | None = None
+    parameters: dict[str, Any] | None = None
+
+    @classmethod
+    def from_contract(cls, value: dict[str, Any] | None) -> "DatabricksEnvironment":
+        if value is None:
+            return cls()
+        env = validate_environment_contract(value)
+        if env["adapter"] != "databricks":
+            raise ValueError("Databricks adapter requires environment.adapter='databricks'")
+        runtime = mapping(env.get("runtime"))
+        deployment = mapping(env.get("deployment"))
+        evidence = mapping(env.get("evidence"))
+        parameters = mapping(env.get("parameters")).get("databricks", {})
+        return cls(
+            name=str(env["name"]),
+            evidence_catalog=str(evidence.get("catalog", "main")),
+            evidence_schema=str(evidence.get("schema", "ops")),
+            workspace_path=str(deployment.get("workspace_path", "/Workspace/ContractForge")).rstrip("/"),
+            bundle_target=str(deployment.get("target", env["name"])),
+            runtime_kind=_first_text(
+                runtime.get("kind"),
+                runtime.get("runtime_type"),
+                parameters.get("runtime_kind"),
+                parameters.get("runtime_type"),
+                parameters.get("runtime"),
+            ),
+            parameters=dict(parameters) if isinstance(parameters, dict) else {},
+        )
+
+def _first_text(*values: object) -> str | None:
+    for value in values:
+        if isinstance(value, str) and value.strip():
+            return value.strip()
+    return None

contractforge_databricks/evidence/__init__.py

@@ -0,0 +1,98 @@
+from contractforge_databricks.evidence.ddl import render_create_evidence_tables_sql
+from contractforge_databricks.evidence.schemas import EVIDENCE_TABLE_COLUMNS, EVIDENCE_TABLE_SCHEMAS
+from contractforge_core.evidence import (
+    AccessEvidenceRecord,
+    CostEvidenceRecord,
+    ErrorEvidenceRecord,
+    LineageEvidenceRecord,
+    QualityEvidenceRecord,
+    QuarantineEvidenceRecord,
+    RunEvidenceRecord,
+    SchemaChangeEvidenceRecord,
+    SourceMetadataEvidenceRecord,
+    StreamBatchEvidenceRecord,
+)
+from contractforge_databricks.evidence.ops_log import (
+    ERROR_COLUMNS,
+    SCHEMA_CHANGE_COLUMNS,
+    STREAM_COLUMNS,
+    render_error_log_insert_sql,
+    render_schema_change_log_insert_sql,
+    render_schema_change_log_insert_sqls,
+    render_stream_child_run_metrics_sql,
+    render_stream_finish_update_sql,
+    render_stream_log_insert_sql,
+)
+from contractforge_databricks.evidence.governance_log import (
+    ACCESS_COLUMNS,
+    ANNOTATION_COLUMNS,
+    OPERATION_COLUMNS,
+    render_access_log_insert_sql,
+    render_access_log_insert_sqls,
+    render_annotation_log_insert_sql,
+    render_annotation_log_insert_sqls,
+    render_operations_log_insert_sql,
+)
+from contractforge_databricks.evidence.run_log import RUN_COLUMNS, render_run_log_insert_sql
+from contractforge_databricks.evidence.sql import (
+    render_access_insert_sql,
+    render_cost_insert_sql,
+    render_error_insert_sql,
+    render_lineage_insert_sql,
+    render_quality_insert_sql,
+    render_quarantine_insert_sql,
+    render_run_insert_sql,
+    render_schema_change_insert_sql,
+    render_source_metadata_insert_sql,
+    render_stream_batch_insert_sql,
+)
+from contractforge_databricks.evidence.tables import evidence_table_names, render_evidence_table_notes
+from contractforge_databricks.evidence.writer import EvidenceWriter
+
+__all__ = [
+    "AccessEvidenceRecord",
+    "ACCESS_COLUMNS",
+    "ANNOTATION_COLUMNS",
+    "CostEvidenceRecord",
+    "ErrorEvidenceRecord",
+    "EvidenceWriter",
+    "EVIDENCE_TABLE_COLUMNS",
+    "EVIDENCE_TABLE_SCHEMAS",
+    "ERROR_COLUMNS",
+    "LineageEvidenceRecord",
+    "QualityEvidenceRecord",
+    "QuarantineEvidenceRecord",
+    "OPERATION_COLUMNS",
+    "RUN_COLUMNS",
+    "SCHEMA_CHANGE_COLUMNS",
+    "STREAM_COLUMNS",
+    "RunEvidenceRecord",
+    "SchemaChangeEvidenceRecord",
+    "SourceMetadataEvidenceRecord",
+    "StreamBatchEvidenceRecord",
+    "evidence_table_names",
+    "render_access_insert_sql",
+    "render_access_log_insert_sql",
+    "render_access_log_insert_sqls",
+    "render_annotation_log_insert_sql",
+    "render_annotation_log_insert_sqls",
+    "render_create_evidence_tables_sql",
+    "render_cost_insert_sql",
+    "render_error_insert_sql",
+    "render_error_log_insert_sql",
+    "render_evidence_table_notes",
+    "render_lineage_insert_sql",
+    "render_operations_log_insert_sql",
+    "render_quality_insert_sql",
+    "render_quarantine_insert_sql",
+    "render_run_insert_sql",
+    "render_run_log_insert_sql",
+    "render_schema_change_insert_sql",
+    "render_schema_change_log_insert_sql",
+    "render_schema_change_log_insert_sqls",
+    "render_source_metadata_insert_sql",
+    "render_stream_child_run_metrics_sql",
+    "render_stream_finish_update_sql",
+    "render_stream_batch_insert_sql",
+    "render_stream_log_insert_sql",
+]

contractforge_databricks/evidence/ddl.py

@@ -0,0 +1,35 @@
+"""Databricks Delta DDL for ContractForge evidence tables."""
+
+from __future__ import annotations
+
+from contractforge_databricks.evidence.tables import evidence_table_names
+from contractforge_databricks.evidence.schemas import EVIDENCE_TABLE_COLUMNS, EVIDENCE_TABLE_SCHEMAS
+from contractforge_databricks.sql import quote_table_name
+
+_PARTITION_COLUMNS = {
+    "runs": "run_date",
+    "errors": "error_date",
+}
+
+
+def render_create_evidence_tables_sql(*, catalog: str = "main", schema: str = "ops") -> str:
+    table_names = evidence_table_names(catalog, schema)
+    statements = [f"CREATE SCHEMA IF NOT EXISTS {quote_table_name(f'{catalog}.{schema}')};"]
+    for name, table in table_names.items():
+        columns = EVIDENCE_TABLE_SCHEMAS[name]
+        partition = _PARTITION_COLUMNS.get(name)
+        partition_sql = f"PARTITIONED BY ({partition})" if partition else ""
+        statements.append(
+            "\n".join(
+                [
+                    f"CREATE TABLE IF NOT EXISTS {quote_table_name(table)} (",
+                    f"  {columns}",
+                    ")",
+                    f"USING DELTA{(' ' + partition_sql) if partition_sql else ''};",
+                ]
+            )
+        )
+    return "\n\n".join(statements) + "\n"
+
+
+__all__ = ["EVIDENCE_TABLE_COLUMNS", "EVIDENCE_TABLE_SCHEMAS", "render_create_evidence_tables_sql"]

contractforge_databricks/evidence/governance_log.py

@@ -0,0 +1,175 @@
+"""Governance and operations control-table SQL rendering."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from contractforge_core.config import CTRL_SCHEMA_VERSION, FRAMEWORK_VERSION
+from contractforge_databricks.evidence.helpers import TimestampClock, cast_sql, utc_timestamp
+from contractforge_databricks.evidence.schemas import EVIDENCE_TABLE_COLUMNS
+from contractforge_databricks.evidence.tables import evidence_table_names
+from contractforge_databricks.security import redact_text, redact_value
+from contractforge_databricks.sql import quote_table_name, sql_int, sql_string
+
+ANNOTATION_COLUMNS = tuple(column.split(" ", 1)[0] for column in EVIDENCE_TABLE_COLUMNS["annotations"])
+ACCESS_COLUMNS = tuple(column.split(" ", 1)[0] for column in EVIDENCE_TABLE_COLUMNS["access"])
+OPERATION_COLUMNS = tuple(column.split(" ", 1)[0] for column in EVIDENCE_TABLE_COLUMNS["operations"])
+INT_COLUMNS = {"ctrl_schema_version", "freshness_sla_minutes"}
+BOOL_COLUMNS = {"revoke_unmanaged", "alert_on_failure", "alert_on_quality_fail"}
+DATE_COLUMNS = {"annotation_date", "access_date"}
+TIMESTAMP_COLUMNS = {"annotation_ts_utc", "access_ts_utc", "applied_at_utc", "recorded_at_utc"}
+
+
+def render_annotation_log_insert_sql(
+    payload: dict[str, Any],
+    *,
+    catalog: str = "main",
+    schema: str = "ops",
+    clock: TimestampClock | None = None,
+) -> str:
+    table = evidence_table_names(catalog, schema)["annotations"]
+    enriched = _annotation_payload(payload, clock=clock)
+    values = [_value(column, _alias(enriched, column)) for column in ANNOTATION_COLUMNS]
+    return f"INSERT INTO {quote_table_name(table)} ({', '.join(ANNOTATION_COLUMNS)}) VALUES ({', '.join(values)})"
+
+
+def render_annotation_log_insert_sqls(
+    *,
+    run_id: str,
+    target_table: str,
+    entries: tuple[dict[str, Any], ...] | list[dict[str, Any]],
+    catalog: str = "main",
+    schema: str = "ops",
+    clock: TimestampClock | None = None,
+) -> tuple[str, ...]:
+    return tuple(
+        render_annotation_log_insert_sql(
+            _annotation_payload({**entry, "run_id": run_id, "target_table": target_table}, clock=clock),
+            catalog=catalog,
+            schema=schema,
+            clock=clock,
+        )
+        for entry in entries
+    )
+
+
+def render_access_log_insert_sql(
+    payload: dict[str, Any],
+    *,
+    catalog: str = "main",
+    schema: str = "ops",
+    clock: TimestampClock | None = None,
+) -> str:
+    table = evidence_table_names(catalog, schema)["access"]
+    enriched = _access_payload(payload, clock=clock)
+    values = [_value(column, _alias(enriched, column)) for column in ACCESS_COLUMNS]
+    return f"INSERT INTO {quote_table_name(table)} ({', '.join(ACCESS_COLUMNS)}) VALUES ({', '.join(values)})"
+
+
+def render_access_log_insert_sqls(
+    *,
+    run_id: str,
+    target_table: str,
+    entries: tuple[dict[str, Any], ...] | list[dict[str, Any]],
+    catalog: str = "main",
+    schema: str = "ops",
+    clock: TimestampClock | None = None,
+) -> tuple[str, ...]:
+    return tuple(
+        render_access_log_insert_sql(
+            _access_payload(
+                {**entry, "access_run_id": entry.get("access_run_id") or run_id, "run_id": run_id, "target_table": target_table},
+                clock=clock,
+            ),
+            catalog=catalog,
+            schema=schema,
+            clock=clock,
+        )
+        for entry in entries
+    )
+
+
+def render_operations_log_insert_sql(
+    payload: dict[str, Any],
+    *,
+    catalog: str = "main",
+    schema: str = "ops",
+    clock: TimestampClock | None = None,
+) -> str:
+    table = evidence_table_names(catalog, schema)["operations"]
+    enriched = _operations_payload(payload, clock=clock)
+    values = [_value(column, enriched.get(column)) for column in OPERATION_COLUMNS]
+    return f"INSERT INTO {quote_table_name(table)} ({', '.join(OPERATION_COLUMNS)}) VALUES ({', '.join(values)})"
+
+
+def _annotation_payload(payload: dict[str, Any], *, clock: TimestampClock | None = None) -> dict[str, Any]:
+    now = _utc_timestamp(clock)
+    return {
+        **payload,
+        "applied_sql": payload.get("applied_sql", payload.get("sql")),
+        "annotation_ts_utc": payload.get("annotation_ts_utc") or now,
+        "annotation_date": payload.get("annotation_date") or now[:10],
+        "framework_version": payload.get("framework_version") or FRAMEWORK_VERSION,
+        "ctrl_schema_version": payload.get("ctrl_schema_version") or CTRL_SCHEMA_VERSION,
+    }
+
+
+def _access_payload(payload: dict[str, Any], *, clock: TimestampClock | None = None) -> dict[str, Any]:
+    now = _utc_timestamp(clock)
+    enriched = {
+        **payload,
+        "applied_sql": payload.get("applied_sql", payload.get("sql")),
+        "action": payload.get("action") or payload.get("access_type"),
+        "access_ts_utc": payload.get("access_ts_utc") or now,
+        "access_date": payload.get("access_date") or now[:10],
+        "applied_at_utc": payload.get("applied_at_utc") or now,
+        "framework_version": payload.get("framework_version") or FRAMEWORK_VERSION,
+        "ctrl_schema_version": payload.get("ctrl_schema_version") or CTRL_SCHEMA_VERSION,
+    }
+    return {**enriched, "payload_json": payload.get("payload_json", enriched)}
+
+
+def _operations_payload(payload: dict[str, Any], *, clock: TimestampClock | None = None) -> dict[str, Any]:
+    return {
+        **payload,
+        "recorded_at_utc": payload.get("recorded_at_utc") or _utc_timestamp(clock),
+        "framework_version": payload.get("framework_version") or FRAMEWORK_VERSION,
+        "ctrl_schema_version": payload.get("ctrl_schema_version") or CTRL_SCHEMA_VERSION,
+    }
+
+
+def _alias(payload: dict[str, Any], column: str) -> Any:
+    if column == "applied_sql":
+        return payload.get("applied_sql", payload.get("sql"))
+    if column == "payload_json" and "payload_json" not in payload:
+        return payload
+    return payload.get(column)
+
+
+def _value(column: str, value: Any) -> str:
+    if column in INT_COLUMNS:
+        return sql_int(value)
+    if column in BOOL_COLUMNS:
+        return "NULL" if value is None else str(bool(value)).lower()
+    if column in DATE_COLUMNS:
+        return cast_sql(value, "DATE")
+    if column in TIMESTAMP_COLUMNS or column.endswith("_utc"):
+        return cast_sql(value, "TIMESTAMP")
+    if column.endswith("_json"):
+        return sql_string(_json_text(value))
+    if column == "error_message":
+        return sql_string(redact_text(str(value))[:2000] if value is not None else None)
+    return sql_string(redact_value(value))
+
+
+def _json_text(value: Any) -> str | None:
+    if value is None:
+        return None
+    if isinstance(value, str):
+        return redact_text(value)
+    return json.dumps(redact_value(value), sort_keys=True, separators=(",", ":"))
+
+
+def _utc_timestamp(clock: TimestampClock | None = None) -> str:
+    return utc_timestamp(clock)

contractforge_databricks/evidence/helpers.py

@@ -0,0 +1,29 @@
+"""Shared Databricks evidence SQL rendering helpers."""
+
+from __future__ import annotations
+
+from datetime import date, datetime, timezone
+from typing import Any, Callable
+
+from contractforge_databricks.sql import sql_string
+
+TimestampClock = Callable[[], datetime | str]
+
+
+def cast_sql(value: Any, sql_type: str) -> str:
+    if value is None:
+        return f"CAST(NULL AS {sql_type})"
+    if isinstance(value, datetime):
+        text = value.strftime("%Y-%m-%d %H:%M:%S")
+    elif isinstance(value, date):
+        text = value.isoformat()
+    else:
+        text = str(value)
+    return f"CAST({sql_string(text)} AS {sql_type})"
+
+
+def utc_timestamp(clock: TimestampClock | None = None) -> str:
+    value = clock() if clock is not None else datetime.now(timezone.utc)
+    if isinstance(value, datetime):
+        return value.astimezone(timezone.utc).strftime("%Y-%m-%d %H:%M:%S")
+    return str(value)

contractforge_databricks/evidence/ops_log.py

@@ -0,0 +1,210 @@
+"""Operational control-table SQL rendering."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from contractforge_core.config import CTRL_SCHEMA_VERSION, FRAMEWORK_VERSION
+from contractforge_databricks.evidence.helpers import TimestampClock, cast_sql, utc_timestamp
+from contractforge_databricks.evidence.schemas import EVIDENCE_TABLE_COLUMNS
+from contractforge_databricks.evidence.tables import evidence_table_names
+from contractforge_databricks.security import redact_text, redact_value
+from contractforge_databricks.sql import quote_identifier, quote_table_name, sql_int, sql_string
+
+ERROR_COLUMNS = tuple(column.split(" ", 1)[0] for column in EVIDENCE_TABLE_COLUMNS["errors"])
+SCHEMA_CHANGE_COLUMNS = tuple(column.split(" ", 1)[0] for column in EVIDENCE_TABLE_COLUMNS["schema_changes"])
+STREAM_COLUMNS = tuple(column.split(" ", 1)[0] for column in EVIDENCE_TABLE_COLUMNS["streams"])
+INT_COLUMNS = {
+    "ctrl_schema_version",
+    "batches_processed",
+    "total_rows_read",
+    "total_rows_written",
+    "total_rows_quarantined",
+}
+FLOAT_COLUMNS = {"duration_seconds"}
+BOOL_COLUMNS = {"applied"}
+DATE_COLUMNS = {"error_date", "access_date", "annotation_date"}
+TIMESTAMP_COLUMNS = {
+    "error_ts_utc",
+    "occurred_at_utc",
+    "change_ts_utc",
+    "changed_at_utc",
+    "started_at_utc",
+    "ended_at_utc",
+    "captured_at_utc",
+}
+
+
+def render_error_log_insert_sql(
+    payload: dict[str, Any],
+    *,
+    catalog: str = "main",
+    schema: str = "ops",
+) -> str:
+    table = evidence_table_names(catalog, schema)["errors"]
+    values = [_value(column, payload.get(column)) for column in ERROR_COLUMNS]
+    return f"INSERT INTO {quote_table_name(table)} ({', '.join(ERROR_COLUMNS)}) VALUES ({', '.join(values)})"
+
+
+def render_schema_change_log_insert_sql(
+    payload: dict[str, Any],
+    *,
+    catalog: str = "main",
+    schema: str = "ops",
+) -> str:
+    table = evidence_table_names(catalog, schema)["schema_changes"]
+    values = [_value(column, payload.get(column)) for column in SCHEMA_CHANGE_COLUMNS]
+    return (
+        f"INSERT INTO {quote_table_name(table)} ({', '.join(SCHEMA_CHANGE_COLUMNS)}) VALUES "
+        f"({', '.join(values)})"
+    )
+
+
+def render_schema_change_log_insert_sqls(
+    *,
+    run_id: str,
+    target_table: str,
+    schema_changes: dict[str, Any],
+    source_schema: dict[str, str] | None = None,
+    catalog: str = "main",
+    schema: str = "ops",
+    clock: TimestampClock | None = None,
+) -> tuple[str, ...]:
+    now = _utc_timestamp(clock)
+    rows = []
+    for column in schema_changes.get("added_columns") or ():
+        source_type = (source_schema or {}).get(column)
+        payload = {"column": column, "source_type": source_type}
+        rows.append(
+            {
+                "run_id": run_id,
+                "change_ts_utc": now,
+                "target_table": target_table,
+                "change_type": "add_column",
+                "column_name": column,
+                "source_type": source_type,
+                "applied": True,
+                "details_json": {},
+                "payload_json": payload,
+                "changed_at_utc": now,
+                "framework_version": FRAMEWORK_VERSION,
+                "ctrl_schema_version": CTRL_SCHEMA_VERSION,
+            }
+        )
+    for change in schema_changes.get("type_changes") or ():
+        rows.append(
+            {
+                "run_id": run_id,
+                "change_ts_utc": now,
+                "target_table": target_table,
+                "change_type": change.get("change", "type_change"),
+                "column_name": change.get("column"),
+                "source_type": change.get("source"),
+                "target_type": change.get("target"),
+                "applied": bool(change.get("applied")),
+                "details_json": change,
+                "payload_json": change,
+                "changed_at_utc": now,
+                "framework_version": FRAMEWORK_VERSION,
+                "ctrl_schema_version": CTRL_SCHEMA_VERSION,
+            }
+        )
+    return tuple(render_schema_change_log_insert_sql(row, catalog=catalog, schema=schema) for row in rows)
+
+
+def render_stream_log_insert_sql(
+    payload: dict[str, Any],
+    *,
+    catalog: str = "main",
+    schema: str = "ops",
+    clock: TimestampClock | None = None,
+) -> str:
+    table = evidence_table_names(catalog, schema)["streams"]
+    enriched = _stream_start_payload(payload, clock=clock)
+    values = [_value(column, enriched.get(column)) for column in STREAM_COLUMNS]
+    return f"INSERT INTO {quote_table_name(table)} ({', '.join(STREAM_COLUMNS)}) VALUES ({', '.join(values)})"
+
+
+def render_stream_finish_update_sql(
+    *,
+    stream_run_id: str,
+    payload: dict[str, Any],
+    catalog: str = "main",
+    schema: str = "ops",
+) -> str | None:
+    assignments = [
+        f"{quote_identifier(column)} = {_value(column, payload[column])}"
+        for column in STREAM_COLUMNS
+        if column != "stream_run_id" and column in payload
+    ]
+    if not assignments:
+        return None
+    table = evidence_table_names(catalog, schema)["streams"]
+    return (
+        f"UPDATE {quote_table_name(table)} SET {', '.join(assignments)} "
+        f"WHERE stream_run_id = {sql_string(stream_run_id)}"
+    )
+
+
+def render_stream_child_run_metrics_sql(
+    *,
+    stream_run_id: str,
+    runs_table: str = "main.ops.ctrl_ingestion_runs",
+) -> str:
+    return "\n".join(
+        [
+            "SELECT",
+            "  count(1) AS batches_processed,",
+            "  sum(coalesce(rows_read, 0)) AS total_rows_read,",
+            "  sum(coalesce(rows_written, 0)) AS total_rows_written,",
+            "  sum(coalesce(rows_quarantined, 0)) AS total_rows_quarantined",
+            f"FROM {quote_table_name(runs_table)}",
+            f"WHERE parent_run_id = {sql_string(stream_run_id)}",
+        ]
+    )
+
+
+def _value(column: str, value: Any) -> str:
+    if column in INT_COLUMNS:
+        return sql_int(value)
+    if column in FLOAT_COLUMNS:
+        return "NULL" if value is None else str(float(value))
+    if column in BOOL_COLUMNS:
+        return "NULL" if value is None else str(bool(value)).lower()
+    if column in DATE_COLUMNS:
+        return cast_sql(value, "DATE")
+    if column in TIMESTAMP_COLUMNS or column.endswith("_utc"):
+        return cast_sql(value, "TIMESTAMP")
+    if column.endswith("_json"):
+        return sql_string(_json_text(value))
+    if column in {"error_message", "stack_trace"}:
+        return sql_string(redact_text(str(value))[:4000] if value is not None else None)
+    return sql_string(redact_value(value))
+
+
+def _json_text(value: Any) -> str | None:
+    if value is None:
+        return None
+    if isinstance(value, str):
+        return redact_text(value)
+    return json.dumps(redact_value(value), sort_keys=True, separators=(",", ":"))
+
+
+def _stream_start_payload(payload: dict[str, Any], *, clock: TimestampClock | None = None) -> dict[str, Any]:
+    now = _utc_timestamp(clock)
+    return {
+        **payload,
+        "started_at_utc": payload.get("started_at_utc") or now,
+        "captured_at_utc": payload.get("captured_at_utc") or now,
+        "batches_processed": payload.get("batches_processed", 0),
+        "total_rows_read": payload.get("total_rows_read", 0),
+        "total_rows_written": payload.get("total_rows_written", 0),
+        "total_rows_quarantined": payload.get("total_rows_quarantined", 0),
+        "framework_version": payload.get("framework_version") or FRAMEWORK_VERSION,
+        "ctrl_schema_version": payload.get("ctrl_schema_version") or CTRL_SCHEMA_VERSION,
+    }
+
+
+def _utc_timestamp(clock: TimestampClock | None = None) -> str:
+    return utc_timestamp(clock)

contractforge_databricks/evidence/records.py

@@ -0,0 +1,27 @@
+"""Compatibility exports for platform-neutral evidence record models."""
+
+from contractforge_core.evidence import (
+    AccessEvidenceRecord,
+    CostEvidenceRecord,
+    ErrorEvidenceRecord,
+    LineageEvidenceRecord,
+    QualityEvidenceRecord,
+    QuarantineEvidenceRecord,
+    RunEvidenceRecord,
+    SchemaChangeEvidenceRecord,
+    SourceMetadataEvidenceRecord,
+    StreamBatchEvidenceRecord,
+)
+
+__all__ = [
+    "AccessEvidenceRecord",
+    "CostEvidenceRecord",
+    "ErrorEvidenceRecord",
+    "LineageEvidenceRecord",
+    "QualityEvidenceRecord",
+    "QuarantineEvidenceRecord",
+    "RunEvidenceRecord",
+    "SchemaChangeEvidenceRecord",
+    "SourceMetadataEvidenceRecord",
+    "StreamBatchEvidenceRecord",
+]