contractforge-databricks 0.1.0__py3-none-any.whl

contractforge_databricks/lineage/openlineage.py

@@ -0,0 +1,182 @@
+"""OpenLineage event rendering for Databricks execution evidence."""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime
+from typing import Any
+
+from contractforge_core.semantic import SemanticContract
+from contractforge_databricks.evidence import LineageEvidenceRecord, render_lineage_insert_sql
+from contractforge_databricks.rendering.names import target_full_name
+from contractforge_databricks.security import redact_value
+
+SchemaField = tuple[str, str]
+
+
+def openlineage_namespace(contract: SemanticContract, *, namespace: str | None = None) -> str:
+    if namespace:
+        return namespace
+    catalog = contract.target.namespace.split(".", 1)[0] if contract.target.namespace else contract.target.layer
+    return f"databricks://{catalog}"
+
+
+def build_openlineage_event(
+    contract: SemanticContract,
+    *,
+    run_id: str,
+    source_name: str,
+    status: str,
+    started_at_utc: datetime,
+    finished_at_utc: datetime,
+    rows_read: int = 0,
+    rows_written: int = 0,
+    input_schema: tuple[SchemaField, ...] = (),
+    output_schema: tuple[SchemaField, ...] = (),
+    delta_version_before: int | None = None,
+    delta_version_after: int | None = None,
+    operation_metrics: dict[str, Any] | None = None,
+    namespace: str | None = None,
+    producer: str = "contractforge-databricks",
+    parent_run_id: str | None = None,
+    spark_version: str | None = None,
+    source_code_url: str | None = None,
+) -> dict[str, Any]:
+    lineage_namespace = openlineage_namespace(contract, namespace=namespace)
+    target = target_full_name(contract)
+    event = {
+        "eventType": "COMPLETE" if status == "SUCCESS" else "FAIL",
+        "eventTime": finished_at_utc.isoformat(),
+        "producer": producer,
+        "schemaURL": "https://openlineage.io/spec/1-0-5/OpenLineage.json",
+        "run": {
+            "runId": run_id,
+            "facets": _clean_none(
+                {
+                    "parent": _parent_facet(parent_run_id, lineage_namespace, contract, producer, source_code_url),
+                    "processing_engine": {
+                        "_producer": producer,
+                        "_schemaURL": "https://openlineage.io/spec/facets/1-0-0/ProcessingEngineRunFacet.json",
+                        "name": "spark",
+                        "version": spark_version,
+                    },
+                }
+            ),
+        },
+        "job": {
+            "namespace": lineage_namespace,
+            "name": f"{contract.target.layer}.{contract.target.name}.{contract.write.mode}",
+            "facets": _clean_none({"sourceCodeLocation": _source_code_facet(source_code_url, producer)}),
+        },
+        "inputs": [_dataset(lineage_namespace, source_name, input_schema, producer)],
+        "outputs": [_output_dataset(lineage_namespace, target, output_schema, rows_written, producer)],
+        "facets": {
+            "contractforge": {
+                "_producer": producer,
+                "_schemaURL": "https://openlineage.io/spec/facets/1-0-0/RunFacet.json",
+                "mode": contract.write.mode,
+                "layer": contract.target.layer,
+                "rowsRead": rows_read,
+                "rowsWritten": rows_written,
+                "deltaVersionBefore": delta_version_before,
+                "deltaVersionAfter": delta_version_after,
+                "operationMetrics": redact_value(operation_metrics or {}),
+                "startedAt": started_at_utc.isoformat(),
+                "finishedAt": finished_at_utc.isoformat(),
+            }
+        },
+    }
+    return redact_value(_clean_none(event))
+
+
+def render_openlineage_insert_sql(
+    contract: SemanticContract,
+    *,
+    run_id: str,
+    source_name: str,
+    status: str,
+    started_at_utc: datetime,
+    finished_at_utc: datetime,
+    catalog: str = "main",
+    schema: str = "ops",
+    **kwargs: Any,
+) -> str:
+    event = build_openlineage_event(
+        contract,
+        run_id=run_id,
+        source_name=source_name,
+        status=status,
+        started_at_utc=started_at_utc,
+        finished_at_utc=finished_at_utc,
+        **kwargs,
+    )
+    record = LineageEvidenceRecord(
+        run_id=run_id,
+        target_table=target_full_name(contract),
+        source_name=source_name,
+        event=json.loads(json.dumps(event, sort_keys=True)),
+        event_time_utc=finished_at_utc,
+    )
+    return render_lineage_insert_sql(record, catalog=catalog, schema=schema)
+
+
+def _dataset(namespace: str, name: str, fields: tuple[SchemaField, ...], producer: str) -> dict[str, Any]:
+    return {
+        "namespace": namespace,
+        "name": name,
+        "facets": {
+            "schema": {
+                "_producer": producer,
+                "_schemaURL": "https://openlineage.io/spec/facets/1-0-0/SchemaDatasetFacet.json",
+                "fields": [{"name": name, "type": dtype} for name, dtype in fields],
+            }
+        },
+    }
+
+
+def _output_dataset(namespace: str, name: str, fields: tuple[SchemaField, ...], row_count: int, producer: str) -> dict[str, Any]:
+    dataset = _dataset(namespace, name, fields, producer)
+    dataset["facets"]["dataQualityMetrics"] = {
+        "_producer": producer,
+        "_schemaURL": "https://openlineage.io/spec/facets/1-0-0/DataQualityMetricsOutputDatasetFacet.json",
+        "rowCount": row_count,
+    }
+    return dataset
+
+
+def _parent_facet(
+    parent_run_id: str | None,
+    namespace: str,
+    contract: SemanticContract,
+    producer: str,
+    source_code_url: str | None,
+) -> dict[str, Any] | None:
+    if not parent_run_id:
+        return None
+    operations = dict(contract.operations.metadata or {}) if contract.operations and contract.operations.metadata else {}
+    job_name = source_code_url or operations.get("notebook_name") or contract.target.name
+    return {
+        "_producer": producer,
+        "_schemaURL": "https://openlineage.io/spec/facets/1-0-0/ParentRunFacet.json",
+        "job": {"namespace": namespace, "name": job_name},
+        "run": {"runId": parent_run_id},
+    }
+
+
+def _source_code_facet(source_code_url: str | None, producer: str) -> dict[str, Any] | None:
+    if not source_code_url:
+        return None
+    return {
+        "_producer": producer,
+        "_schemaURL": "https://openlineage.io/spec/facets/1-0-0/SourceCodeLocationJobFacet.json",
+        "type": "notebook",
+        "url": source_code_url,
+    }
+
+
+def _clean_none(value: Any) -> Any:
+    if isinstance(value, dict):
+        return {key: _clean_none(item) for key, item in value.items() if item is not None}
+    if isinstance(value, list):
+        return [_clean_none(item) for item in value if item is not None]
+    return value

contractforge_databricks/maintenance/__init__.py

@@ -0,0 +1,27 @@
+from contractforge_databricks.maintenance.retention import (
+    CONTROL_RETENTION_TARGETS,
+    ControlRetentionTarget,
+    build_control_retention_plan,
+    execute_control_retention_plan,
+)
+from contractforge_databricks.maintenance.sql import (
+    MaintenancePlan,
+    execute_maintenance_plan,
+    render_alter_table_properties_sql,
+    render_analyze_sql,
+    render_optimize_sql,
+    render_vacuum_sql,
+)
+
+__all__ = [
+    "MaintenancePlan",
+    "CONTROL_RETENTION_TARGETS",
+    "ControlRetentionTarget",
+    "execute_control_retention_plan",
+    "execute_maintenance_plan",
+    "build_control_retention_plan",
+    "render_alter_table_properties_sql",
+    "render_analyze_sql",
+    "render_optimize_sql",
+    "render_vacuum_sql",
+]

contractforge_databricks/maintenance/retention.py

@@ -0,0 +1,90 @@
+"""Control-table retention planning for Databricks evidence tables."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Iterable
+
+from contractforge_databricks.execution.sql_merge import SqlRunner
+from contractforge_databricks.sql import quote_identifier, quote_table_name
+
+
+@dataclass(frozen=True)
+class ControlRetentionTarget:
+    key: str
+    table: str
+    age_expression: str
+    description: str
+
+
+CONTROL_RETENTION_TARGETS: tuple[ControlRetentionTarget, ...] = (
+    ControlRetentionTarget("runs", "ctrl_ingestion_runs", "run_date", "Run history"),
+    ControlRetentionTarget("errors", "ctrl_ingestion_errors", "error_date", "Error stack traces"),
+    ControlRetentionTarget("quality", "ctrl_ingestion_quality", "checked_at_utc", "Quality results"),
+    ControlRetentionTarget("quarantine", "ctrl_ingestion_quarantine", "quarantined_at_utc", "Quarantine references"),
+    ControlRetentionTarget("locks", "ctrl_ingestion_locks", "COALESCE(released_at_utc, expires_at_utc, acquired_at_utc)", "Expired or released locks"),
+    ControlRetentionTarget("explain", "ctrl_ingestion_explain", "captured_at_utc", "Explain plans"),
+    ControlRetentionTarget("lineage", "ctrl_ingestion_lineage", "event_time_utc", "Lineage events"),
+    ControlRetentionTarget("schema_changes", "ctrl_ingestion_schema_changes", "change_ts_utc", "Schema changes"),
+    ControlRetentionTarget("streams", "ctrl_ingestion_streams", "COALESCE(ended_at_utc, started_at_utc)", "Stream history"),
+    ControlRetentionTarget("annotations", "ctrl_ingestion_annotations", "annotation_date", "Annotation audit"),
+    ControlRetentionTarget("operations", "ctrl_ingestion_operations", "recorded_at_utc", "Operational audit"),
+    ControlRetentionTarget("access", "ctrl_ingestion_access", "access_date", "Access audit"),
+    ControlRetentionTarget("cost", "ctrl_ingestion_cost", "captured_at_utc", "Cost signals"),
+)
+
+
+def build_control_retention_plan(
+    *,
+    catalog: str = "main",
+    schema: str = "ops",
+    retention_days: int,
+    vacuum: bool = False,
+    vacuum_retention_hours: int = 168,
+    targets: Iterable[str] | None = None,
+) -> tuple[dict[str, Any], ...]:
+    if retention_days < 1:
+        raise ValueError("retention_days must be greater than or equal to 1")
+    if vacuum_retention_hours < 0:
+        raise ValueError("vacuum_retention_hours must be greater than or equal to 0")
+    requested = {str(target) for target in (targets or [])}
+    known = {target.key for target in CONTROL_RETENTION_TARGETS}
+    unknown = requested - known
+    if unknown:
+        raise ValueError(f"unknown ctrl retention targets: {sorted(unknown)}")
+    plan = []
+    for target in CONTROL_RETENTION_TARGETS:
+        if requested and target.key not in requested:
+            continue
+        table = f"{catalog}.{schema}.{target.table}"
+        predicate = _cutoff_predicate(target.age_expression, retention_days)
+        commands = [f"DELETE FROM {quote_table_name(table)} WHERE {predicate}"]
+        if vacuum:
+            commands.append(f"VACUUM {quote_table_name(table)} RETAIN {int(vacuum_retention_hours)} HOURS")
+        plan.append(
+            {
+                "target": target.key,
+                "table": table,
+                "description": target.description,
+                "retention_days": retention_days,
+                "predicate": predicate,
+                "commands": commands,
+            }
+        )
+    return tuple(plan)
+
+
+def execute_control_retention_plan(runner: SqlRunner, plan: Iterable[dict[str, Any]]) -> tuple[str, ...]:
+    executed = []
+    for item in plan:
+        for command in item["commands"]:
+            runner.sql(str(command))
+            executed.append(str(command))
+    return tuple(executed)
+
+
+def _cutoff_predicate(age_expression: str, retention_days: int) -> str:
+    expression = age_expression.strip()
+    if expression.endswith("_date") and "(" not in expression:
+        return f"{quote_identifier(expression)} < date_sub(current_date(), {int(retention_days)})"
+    return f"{expression} < current_timestamp() - INTERVAL {int(retention_days)} DAYS"

contractforge_databricks/maintenance/sql.py

@@ -0,0 +1,68 @@
+"""Databricks table maintenance SQL helpers."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from contractforge_databricks.execution.sql_merge import SqlRunner
+from contractforge_databricks.sql import quote_identifier, quote_table_name
+
+
+@dataclass(frozen=True)
+class MaintenancePlan:
+    target_table: str
+    optimize: bool = False
+    zorder_columns: tuple[str, ...] = ()
+    vacuum_retention_hours: int | None = None
+    analyze: bool = False
+    delta_properties: dict[str, str] | None = None
+
+
+def render_optimize_sql(target_table: str, *, zorder_columns: tuple[str, ...] = ()) -> str:
+    statement = f"OPTIMIZE {quote_table_name(target_table)}"
+    if zorder_columns:
+        columns = ", ".join(quote_identifier(column) for column in zorder_columns)
+        statement += f" ZORDER BY ({columns})"
+    return statement
+
+
+def render_vacuum_sql(target_table: str, *, retention_hours: int) -> str:
+    if retention_hours < 0:
+        raise ValueError("vacuum retention must be non-negative")
+    return f"VACUUM {quote_table_name(target_table)} RETAIN {retention_hours} HOURS"
+
+
+def render_analyze_sql(target_table: str) -> str:
+    return f"ANALYZE TABLE {quote_table_name(target_table)} COMPUTE STATISTICS"
+
+
+def render_alter_table_properties_sql(target_table: str, properties: dict[str, str]) -> str:
+    if not properties:
+        raise ValueError("delta properties must not be empty")
+    props = ", ".join(f"{_sql_string(key)} = {_sql_string(value)}" for key, value in sorted(properties.items()))
+    return f"ALTER TABLE {quote_table_name(target_table)} SET TBLPROPERTIES ({props})"
+
+
+def render_maintenance_plan_sql(plan: MaintenancePlan) -> tuple[str, ...]:
+    statements: list[str] = []
+    if plan.delta_properties:
+        statements.append(render_alter_table_properties_sql(plan.target_table, plan.delta_properties))
+    if plan.optimize:
+        statements.append(render_optimize_sql(plan.target_table, zorder_columns=plan.zorder_columns))
+    if plan.vacuum_retention_hours is not None:
+        statements.append(render_vacuum_sql(plan.target_table, retention_hours=plan.vacuum_retention_hours))
+    if plan.analyze:
+        statements.append(render_analyze_sql(plan.target_table))
+    return tuple(statements)
+
+
+def execute_maintenance_plan(runner: SqlRunner, plan: MaintenancePlan) -> tuple[str, ...]:
+    statements = render_maintenance_plan_sql(plan)
+    for statement in statements:
+        runner.sql(statement)
+    return statements
+
+
+def _sql_string(value: object) -> str:
+    return "'" + str(value).replace("'", "''") + "'"
+

contractforge_databricks/metrics/__init__.py

@@ -0,0 +1,19 @@
+from contractforge_databricks.metrics.history import (
+    latest_operation_metrics_from_history_row,
+    render_delta_history_query,
+)
+from contractforge_databricks.metrics.write import (
+    extract_delta_row_metrics,
+    logical_row_metrics,
+    normalize_rows_written,
+    resolve_write_metrics,
+)
+
+__all__ = [
+    "extract_delta_row_metrics",
+    "latest_operation_metrics_from_history_row",
+    "logical_row_metrics",
+    "normalize_rows_written",
+    "render_delta_history_query",
+    "resolve_write_metrics",
+]

contractforge_databricks/metrics/history.py

@@ -0,0 +1,21 @@
+"""Delta history metric helpers."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from contractforge_databricks.sql import quote_table_name
+
+
+def render_delta_history_query(*, target_table: str, limit: int = 1) -> str:
+    return f"DESCRIBE HISTORY {quote_table_name(target_table)} LIMIT {int(limit)}"
+
+
+def latest_operation_metrics_from_history_row(row: dict[str, Any] | None) -> dict[str, Any]:
+    if not row:
+        return {}
+    return {
+        "version": row.get("version"),
+        "operation": row.get("operation"),
+        "operationMetrics": row.get("operationMetrics") or {},
+    }

contractforge_databricks/metrics/write.py

@@ -0,0 +1,63 @@
+"""Databricks Delta write metric normalization."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from contractforge_core.metrics import (
+    logical_row_metrics as core_logical_row_metrics,
+    normalize_rows_written as normalize_rows_written,
+)
+from contractforge_core.semantic import SemanticContract
+from contractforge_databricks.contract_extensions import databricks_extensions
+
+
+def extract_delta_row_metrics(metrics: dict[str, Any]) -> dict[str, int]:
+    operation = metrics.get("operationMetrics") or {}
+
+    def parse(*names: str) -> int:
+        for name in names:
+            if name in operation and operation[name] is not None:
+                try:
+                    return int(operation[name])
+                except Exception:
+                    return 0
+        return 0
+
+    return {
+        "rows_inserted": parse("numTargetRowsInserted", "numOutputRows"),
+        "rows_updated": parse("numTargetRowsUpdated"),
+        "rows_deleted": parse("numTargetRowsDeleted"),
+        "rows_expired": 0,
+    }
+
+
+def resolve_write_metrics(
+    contract: SemanticContract,
+    rows_written: int,
+    delta_metrics: dict[str, Any],
+) -> tuple[dict[str, int], dict[str, Any], str]:
+    logical = logical_row_metrics(contract, rows_written)
+    operation_metrics = dict(delta_metrics or {})
+    operation_metrics["logicalMetrics"] = logical
+    if operation_metrics.get("operationMetrics"):
+        row_metrics = extract_delta_row_metrics(operation_metrics)
+        if contract.write.mode == "scd2_historical":
+            row_metrics["rows_expired"] = row_metrics["rows_updated"]
+        delta_rows_affected = row_metrics["rows_inserted"] + row_metrics["rows_updated"] + row_metrics["rows_deleted"]
+        row_metrics["rows_affected"] = max(logical["rows_affected"], delta_rows_affected)
+        operation_metrics["normalizedRowMetrics"] = row_metrics
+        return row_metrics, operation_metrics, "mixed"
+    operation_metrics["normalizedRowMetrics"] = logical
+    return logical, operation_metrics, "logical"
+
+
+def logical_row_metrics(contract: SemanticContract, rows_written: int) -> dict[str, int]:
+    logical = core_logical_row_metrics(contract, rows_written)
+    if (
+        int(rows_written or 0) > 0
+        and contract.write.mode == "scd1_upsert"
+        and databricks_extensions(contract).get("merge_strategy") == "replace_partitions"
+    ):
+        logical["rows_inserted"] = int(rows_written)
+    return logical

contractforge_databricks/operations/__init__.py

@@ -0,0 +1,4 @@
+from contractforge_databricks.operations.application import record_operations_contract
+from contractforge_databricks.operations.sql import render_operations_insert_sql, render_operations_json
+
+__all__ = ["record_operations_contract", "render_operations_insert_sql", "render_operations_json"]

contractforge_databricks/operations/application.py

@@ -0,0 +1,38 @@
+"""Record Databricks operations metadata with an injected SQL runner."""
+
+from __future__ import annotations
+
+from datetime import datetime
+
+from contractforge_core.results import OperationsRecordResult
+from contractforge_core.semantic import SemanticContract
+from contractforge_databricks.environment import DatabricksEnvironment
+from contractforge_databricks.execution.sql_merge import SqlRunner
+from contractforge_databricks.operations.sql import has_operations_metadata, render_operations_insert_sql
+from contractforge_databricks.security import exception_message
+
+
+def record_operations_contract(
+    *,
+    runner: SqlRunner,
+    contract: SemanticContract,
+    environment: DatabricksEnvironment | None = None,
+    run_id: str = "${run_id}",
+    recorded_at_utc: datetime | None = None,
+) -> OperationsRecordResult:
+    if not has_operations_metadata(contract):
+        return OperationsRecordResult(status="NOT_CONFIGURED")
+    env = environment or DatabricksEnvironment()
+    statement = render_operations_insert_sql(
+        contract,
+        run_id=run_id,
+        status="RECORDED",
+        recorded_at_utc=recorded_at_utc,
+        catalog=env.evidence_catalog,
+        schema=env.evidence_schema,
+    )
+    try:
+        runner.sql(statement)
+    except Exception as exc:
+        return OperationsRecordResult(status="FAILED", sql=statement, error=exception_message(exc))
+    return OperationsRecordResult(status="RECORDED", sql=statement)

contractforge_databricks/operations/sql.py

@@ -0,0 +1,95 @@
+"""Render Databricks operations metadata evidence."""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime
+from typing import Any
+
+from contractforge_core.semantic import SemanticContract
+from contractforge_databricks.coercion import mapping, string_list
+from contractforge_databricks.evidence.tables import evidence_table_names
+from contractforge_databricks.rendering.names import target_full_name
+from contractforge_databricks.sql import quote_table_name, sql_int, sql_string
+
+_COLUMNS = [
+    "run_id",
+    "target_table",
+    "criticality",
+    "expected_frequency",
+    "freshness_sla_minutes",
+    "alert_on_failure",
+    "alert_on_quality_fail",
+    "runbook_url",
+    "ownership_json",
+    "owners_json",
+    "groups_json",
+    "tags_json",
+    "status",
+    "recorded_at_utc",
+]
+
+
+def render_operations_json(contract: SemanticContract) -> str:
+    return json.dumps(_operations_payload(contract), indent=2, sort_keys=True)
+
+
+def has_operations_metadata(contract: SemanticContract) -> bool:
+    return bool(contract.operations and contract.operations.metadata)
+
+
+def render_operations_insert_sql(
+    contract: SemanticContract,
+    *,
+    run_id: str = "${run_id}",
+    status: str = "PLANNED",
+    recorded_at_utc: datetime | None = None,
+    catalog: str = "main",
+    schema: str = "ops",
+) -> str:
+    payload = _operations_payload(contract)
+    table = evidence_table_names(catalog, schema)["operations"]
+    recorded_at_utc = recorded_at_utc or datetime(1970, 1, 1, 0, 0, 0)
+    values = [
+        sql_string(run_id),
+        sql_string(target_full_name(contract)),
+        sql_string(payload.get("criticality")),
+        sql_string(payload.get("expected_frequency")),
+        sql_int(payload.get("freshness_sla_minutes")),
+        _sql_bool(payload.get("alert_on_failure")),
+        _sql_bool(payload.get("alert_on_quality_fail")),
+        sql_string(payload.get("runbook_url")),
+        _json(payload.get("ownership")),
+        _json(payload.get("owners")),
+        _json(payload.get("groups")),
+        _json(payload.get("tags")),
+        sql_string(status),
+        f"TIMESTAMP {sql_string(recorded_at_utc.strftime('%Y-%m-%d %H:%M:%S'))}",
+    ]
+    return f"INSERT INTO {quote_table_name(table)} ({', '.join(_COLUMNS)}) VALUES ({', '.join(values)})"
+
+
+def _operations_payload(contract: SemanticContract) -> dict[str, Any]:
+    raw = contract.operations.metadata if contract.operations and contract.operations.metadata else {}
+    ownership = mapping(raw.get("ownership"))
+    operations = mapping(raw.get("operations")) or raw
+    return {
+        "criticality": operations.get("criticality"),
+        "expected_frequency": operations.get("expected_frequency"),
+        "freshness_sla_minutes": operations.get("freshness_sla_minutes"),
+        "alert_on_failure": bool(operations.get("alert_on_failure", False)),
+        "alert_on_quality_fail": bool(operations.get("alert_on_quality_fail", False)),
+        "runbook_url": operations.get("runbook_url"),
+        "ownership": ownership,
+        "owners": string_list(operations.get("owners"), sep="|"),
+        "groups": string_list(operations.get("groups"), sep="|"),
+        "tags": mapping(operations.get("tags")),
+    }
+
+
+def _json(value: object) -> str:
+    return sql_string(json.dumps(value, sort_keys=True, separators=(",", ":")))
+
+
+def _sql_bool(value: object) -> str:
+    return "true" if bool(value) else "false"

contractforge_databricks/parity/__init__.py

@@ -0,0 +1,18 @@
+from contractforge_databricks.parity.catalog import (
+    build_write_engine_parity_plan,
+    get_write_engine_parity_scenario,
+    list_write_engine_parity_scenarios,
+    scenarios_for_engine,
+    scenarios_for_mode,
+)
+from contractforge_core.parity import ParityMetricExpectation, WriteEngineParityScenario
+
+__all__ = [
+    "ParityMetricExpectation",
+    "WriteEngineParityScenario",
+    "build_write_engine_parity_plan",
+    "get_write_engine_parity_scenario",
+    "list_write_engine_parity_scenarios",
+    "scenarios_for_engine",
+    "scenarios_for_mode",
+]